pkg/analysis_server/lib/src/lsp/source_edits.dart - sdk.git - Git at Google

 // Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
 import 'package:analysis_server/lsp_protocol/protocol_special.dart';
 import 'package:analysis_server/src/lsp/mapping.dart';
 import 'package:analysis_server/src/protocol_server.dart' as server
     show SourceEdit;
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
 import 'package:analyzer_plugin/utilities/pair.dart';
 import 'package:dart_style/dart_style.dart';

 DartFormatter formatter = DartFormatter();

 /// Transforms a sequence of LSP document change events to a sequence of source
 /// edits used by analysis plugins.
 ///
 /// Since the translation from line/characters to offsets needs to take previous
 /// changes into account, this will also apply the edits to [oldContent].
 ErrorOr<Pair<String, List<plugin.SourceEdit>>> applyAndConvertEditsToServer(
   String oldContent,
   List<
           Either2<TextDocumentContentChangeEvent1,
               TextDocumentContentChangeEvent2>>
       changes, {
   bool failureIsCritical = false,
 }) {
   var newContent = oldContent;
   final serverEdits = <server.SourceEdit>[];

   for (var change in changes) {
     // Change is a union that may/may not include a range. If no range
     // is provided (t2 of the union) the whole document should be replaced.
     final result = change.map(
       // TextDocumentContentChangeEvent1
       // {range, text}
       (change) {
         final lines = LineInfo.fromContent(newContent);
         final offsetStart = toOffset(lines, change.range.start,
             failureIsCritical: failureIsCritical);
         final offsetEnd = toOffset(lines, change.range.end,
             failureIsCritical: failureIsCritical);
         if (offsetStart.isError) {
           return ErrorOr.error(offsetStart.error);
         }
         if (offsetEnd.isError) {
           return ErrorOr.error(offsetEnd.error);
         }
         newContent = newContent.replaceRange(
             offsetStart.result, offsetEnd.result, change.text);
         serverEdits.add(server.SourceEdit(offsetStart.result,
             offsetEnd.result - offsetStart.result, change.text));
       },
       // TextDocumentContentChangeEvent2
       // {text}
       (change) {
         serverEdits
           ..clear()
           ..add(server.SourceEdit(0, newContent.length, change.text));
         newContent = change.text;
       },
     );
     // If any change fails, immediately return the error.
     if (result != null && result.isError) {
       return ErrorOr.error(result.error);
     }
   }
   return ErrorOr.success(Pair(newContent, serverEdits));
 }

 ErrorOr<List<TextEdit>?> generateEditsForFormatting(
   ParsedUnitResult result,
   int? lineLength, {
   Range? range,
 }) {
   final unformattedSource = result.content;

   final code =
       SourceCode(unformattedSource, uri: null, isCompilationUnit: true);
   SourceCode formattedResult;
   try {
     // If the lineLength has changed, recreate the formatter with the new setting.
     if (lineLength != formatter.pageWidth) {
       formatter = DartFormatter(pageWidth: lineLength);
     }
     formattedResult = formatter.formatSource(code);
   } on FormatterException {
     // If the document fails to parse, just return no edits to avoid the
     // use seeing edits on every save with invalid code (if LSP gains the
     // ability to pass a context to know if the format was manually invoked
     // we may wish to change this to return an error for that case).
     return success(null);
   }
   final formattedSource = formattedResult.text;

   if (formattedSource == unformattedSource) {
     return success(null);
   }

   return _generateMinimalEdits(result, formattedSource, range: range);
 }

 List<TextEdit> _generateFullEdit(
     LineInfo lineInfo, String unformattedSource, String formattedSource) {
   final end = lineInfo.getLocation(unformattedSource.length);
   return [
     TextEdit(
       range:
           Range(start: Position(line: 0, character: 0), end: toPosition(end)),
       newText: formattedSource,
     )
   ];
 }

 /// Generates edits that modify the minimum amount of code (only whitespace) to
 /// change [unformatted] to [formatted].
 ///
 /// This allows editors to more easily track important locations (such as
 /// breakpoints) without needing to do their own diffing.
 ///
 /// If [range] is supplied, only whitespace edits that fall entirely inside this
 /// range will be included in the results.
 ErrorOr<List<TextEdit>> _generateMinimalEdits(
   ParsedUnitResult result,
   String formatted, {
   Range? range,
 }) {
   final unformatted = result.content;
   final lineInfo = result.lineInfo;
   final rangeStart = range != null ? toOffset(lineInfo, range.start) : null;
   final rangeEnd = range != null ? toOffset(lineInfo, range.end) : null;

   if (rangeStart != null && rangeStart.isError) {
     return failure(rangeStart);
   }
   if (rangeEnd != null && rangeEnd.isError) {
     return failure(rangeEnd);
   }

   // It shouldn't be the case that we can't parse the code but if it happens
   // fall back to a full replacement rather than fail.
   final parsedFormatted = _parse(formatted, result.unit.featureSet);
   final parsedUnformatted = _parse(unformatted, result.unit.featureSet);
   if (parsedFormatted == null || parsedUnformatted == null) {
     return success(_generateFullEdit(lineInfo, unformatted, formatted));
   }

   final unformattedTokens = _iterateAllTokens(parsedUnformatted).iterator;
   final formattedTokens = _iterateAllTokens(parsedFormatted).iterator;

   var unformattedOffset = 0;
   var formattedOffset = 0;
   final edits = <TextEdit>[];

   /// Helper for comparing whitespace and appending an edit.
   void addEditFor(
     int unformattedStart,
     int unformattedEnd,
     int formattedStart,
     int formattedEnd,
   ) {
     final unformattedWhitespace =
         unformatted.substring(unformattedStart, unformattedEnd);
     final formattedWhitespace =
         formatted.substring(formattedStart, formattedEnd);

     if (rangeStart != null && rangeEnd != null) {
       // If this change crosses over the start of the requested range, discarding
       // the change may result in leading whitespace of the next line not being
       // formatted correctly.
       //
       // To handle this, if both unformatted/formatted contain at least one
       // newline, split this change into two around the last newline so that the
       // final part (likely leading whitespace) can be included without
       // including the whole change. This cannot be done if the newline is at
       // the end of the source whitespace though, as this would create a split
       // where the first part is the same and the second part is empty,
       // resulting in an infinite loop/stack overflow.
       //
       // Without this, functionality like VS Code's "format modified lines"
       // (which uses Git status to know which lines are edited) may appear to
       // fail to format the first newly added line in a range.
       if (unformattedStart < rangeStart.result &&
           unformattedEnd > rangeStart.result &&
           unformattedWhitespace.contains('\n') &&
           formattedWhitespace.contains('\n') &&
           !unformattedWhitespace.endsWith('\n')) {
         // Find the offsets of the character after the last newlines.
         final unformattedOffset = unformattedWhitespace.lastIndexOf('\n') + 1;
         final formattedOffset = formattedWhitespace.lastIndexOf('\n') + 1;
         // Call us again for the leading part
         addEditFor(
           unformattedStart,
           unformattedStart + unformattedOffset,
           formattedStart,
           formattedStart + formattedOffset,
         );
         // Call us again for the trailing part
         addEditFor(
           unformattedStart + unformattedOffset,
           unformattedEnd,
           formattedStart + formattedOffset,
           formattedEnd,
         );
         return;
       }

       // If we're formatting only a range, skip over any segments that don't fall
       // entirely within that range.
       if (unformattedStart < rangeStart.result ||
           unformattedEnd > rangeEnd.result) {
         return;
       }
     }

     if (unformattedWhitespace == formattedWhitespace) {
       return;
     }

     // Validate we didn't find more than whitespace. If this occurs, it's likely
     // the token offsets used were incorrect. In this case it's better to not
     // modify the code than potentially remove something important.
     if (unformattedWhitespace.trim().isNotEmpty ||
         formattedWhitespace.trim().isNotEmpty) {
       return;
     }

     var startOffset = unformattedStart;
     var endOffset = unformattedEnd;
     var newText = formattedWhitespace;

     // Simplify some common cases where the new whitespace is a subset of
     // the old.
     if (formattedWhitespace.isNotEmpty) {
       if (unformattedWhitespace.startsWith(formattedWhitespace)) {
         startOffset = unformattedStart + formattedWhitespace.length;
         newText = '';
       } else if (unformattedWhitespace.endsWith(formattedWhitespace)) {
         endOffset = unformattedEnd - formattedWhitespace.length;
         newText = '';
       }
     }

     // Finally, append the edit for this whitespace.
     // Note: As with all LSP edits, offsets are based on the original location
     // as they are applied in one shot. They should not account for the previous
     // edits in the same set.
     edits.add(TextEdit(
       range: Range(
         start: toPosition(lineInfo.getLocation(startOffset)),
         end: toPosition(lineInfo.getLocation(endOffset)),
       ),
       newText: newText,
     ));
   }

   // Process the whitespace before each token.
   bool unformattedHasMore, formattedHasMore;
   while ((unformattedHasMore =
           unformattedTokens.moveNext()) & // Don't short-circuit
       (formattedHasMore = formattedTokens.moveNext())) {
     final unformattedToken = unformattedTokens.current;
     final formattedToken = formattedTokens.current;

     if (unformattedToken.lexeme != formattedToken.lexeme) {
       // If the token lexems do not match, there is a difference in the parsed
       // token streams (this should not ordinarily happen) so fall back to a
       // full edit.
       return success(_generateFullEdit(lineInfo, unformatted, formatted));
     }

     addEditFor(
       unformattedOffset,
       unformattedToken.offset,
       formattedOffset,
       formattedToken.offset,
     );

     // When range formatting, if we've processed a token that ends after the
     // range then there can't be any more relevant edits and we can return early.
     if (rangeEnd != null && unformattedToken.end > rangeEnd.result) {
       return success(edits);
     }

     unformattedOffset = unformattedToken.end;
     formattedOffset = formattedToken.end;
   }

   // If we got here and either of the streams still have tokens, something
   // did not match so fall back to a full edit.
   if (unformattedHasMore || formattedHasMore) {
     return success(_generateFullEdit(lineInfo, unformatted, formatted));
   }

   // Finally, handle any whitespace that was after the last token.
   addEditFor(
     unformattedOffset,
     unformatted.length,
     formattedOffset,
     formatted.length,
   );

   return success(edits);
 }

 /// Iterates over a token stream returning all tokens including comments.
 Iterable<Token> _iterateAllTokens(Token token) sync* {
   while (token.type != TokenType.EOF) {
     Token? commentToken = token.precedingComments;
     while (commentToken != null) {
       yield commentToken;
       commentToken = commentToken.next;
     }
     yield token;
     token = token.next!;
   }
 }

 /// Parse and return the first of the given Dart source, `null` if code cannot
 /// be parsed.
 Token? _parse(String s, FeatureSet featureSet) {
   try {
     var scanner = Scanner(_SourceMock.instance, CharSequenceReader(s),
         AnalysisErrorListener.NULL_LISTENER)
       ..configureFeatures(
         featureSetForOverriding: featureSet,
         featureSet: featureSet,
       );
     return scanner.tokenize();
   } catch (e) {
     return null;
   }
 }

 /// Helper class that bundles up all information required when converting server
 /// SourceEdits into LSP-compatible WorkspaceEdits.
 class FileEditInformation {
   final OptionalVersionedTextDocumentIdentifier doc;
   final LineInfo lineInfo;
   final List<server.SourceEdit> edits;
   final bool newFile;

   /// The selection offset, relative to the edit.
   final int? selectionOffsetRelative;
   final int? selectionLength;

   FileEditInformation(this.doc, this.lineInfo, this.edits,
       {this.newFile = false,
       this.selectionOffsetRelative,
       this.selectionLength});
 }

 class _SourceMock implements Source {
   static final Source instance = _SourceMock();

   @override
   dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
	// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
	import 'package:analysis_server/lsp_protocol/protocol_special.dart';
	import 'package:analysis_server/src/lsp/mapping.dart';
	import 'package:analysis_server/src/protocol_server.dart' as server
	show SourceEdit;
	import 'package:analyzer/dart/analysis/features.dart';
	import 'package:analyzer/dart/analysis/results.dart';
	import 'package:analyzer/dart/ast/token.dart';
	import 'package:analyzer/error/listener.dart';
	import 'package:analyzer/src/dart/scanner/reader.dart';
	import 'package:analyzer/src/dart/scanner/scanner.dart';
	import 'package:analyzer/src/generated/source.dart';
	import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
	import 'package:analyzer_plugin/utilities/pair.dart';
	import 'package:dart_style/dart_style.dart';

	DartFormatter formatter = DartFormatter();

	/// Transforms a sequence of LSP document change events to a sequence of source
	/// edits used by analysis plugins.
	///
	/// Since the translation from line/characters to offsets needs to take previous
	/// changes into account, this will also apply the edits to [oldContent].
	ErrorOr<Pair<String, List<plugin.SourceEdit>>> applyAndConvertEditsToServer(
	String oldContent,
	List<
	Either2<TextDocumentContentChangeEvent1,
	TextDocumentContentChangeEvent2>>
	changes, {
	bool failureIsCritical = false,
	}) {
	var newContent = oldContent;
	final serverEdits = <server.SourceEdit>[];

	for (var change in changes) {
	// Change is a union that may/may not include a range. If no range
	// is provided (t2 of the union) the whole document should be replaced.
	final result = change.map(
	// TextDocumentContentChangeEvent1
	// {range, text}
	(change) {
	final lines = LineInfo.fromContent(newContent);
	final offsetStart = toOffset(lines, change.range.start,
	failureIsCritical: failureIsCritical);
	final offsetEnd = toOffset(lines, change.range.end,
	failureIsCritical: failureIsCritical);
	if (offsetStart.isError) {
	return ErrorOr.error(offsetStart.error);
	}
	if (offsetEnd.isError) {
	return ErrorOr.error(offsetEnd.error);
	}
	newContent = newContent.replaceRange(
	offsetStart.result, offsetEnd.result, change.text);
	serverEdits.add(server.SourceEdit(offsetStart.result,
	offsetEnd.result - offsetStart.result, change.text));
	},
	// TextDocumentContentChangeEvent2
	// {text}
	(change) {
	serverEdits
	..clear()
	..add(server.SourceEdit(0, newContent.length, change.text));
	newContent = change.text;
	},
	);
	// If any change fails, immediately return the error.
	if (result != null && result.isError) {
	return ErrorOr.error(result.error);
	}
	}
	return ErrorOr.success(Pair(newContent, serverEdits));
	}

	ErrorOr<List<TextEdit>?> generateEditsForFormatting(
	ParsedUnitResult result,
	int? lineLength, {
	Range? range,
	}) {
	final unformattedSource = result.content;

	final code =
	SourceCode(unformattedSource, uri: null, isCompilationUnit: true);
	SourceCode formattedResult;
	try {
	// If the lineLength has changed, recreate the formatter with the new setting.
	if (lineLength != formatter.pageWidth) {
	formatter = DartFormatter(pageWidth: lineLength);
	}
	formattedResult = formatter.formatSource(code);
	} on FormatterException {
	// If the document fails to parse, just return no edits to avoid the
	// use seeing edits on every save with invalid code (if LSP gains the
	// ability to pass a context to know if the format was manually invoked
	// we may wish to change this to return an error for that case).
	return success(null);
	}
	final formattedSource = formattedResult.text;

	if (formattedSource == unformattedSource) {
	return success(null);
	}

	return _generateMinimalEdits(result, formattedSource, range: range);
	}

	List<TextEdit> _generateFullEdit(
	LineInfo lineInfo, String unformattedSource, String formattedSource) {
	final end = lineInfo.getLocation(unformattedSource.length);
	return [
	TextEdit(
	range:
	Range(start: Position(line: 0, character: 0), end: toPosition(end)),
	newText: formattedSource,
	)
	];
	}

	/// Generates edits that modify the minimum amount of code (only whitespace) to
	/// change [unformatted] to [formatted].
	///
	/// This allows editors to more easily track important locations (such as
	/// breakpoints) without needing to do their own diffing.
	///
	/// If [range] is supplied, only whitespace edits that fall entirely inside this
	/// range will be included in the results.
	ErrorOr<List<TextEdit>> _generateMinimalEdits(
	ParsedUnitResult result,
	String formatted, {
	Range? range,
	}) {
	final unformatted = result.content;
	final lineInfo = result.lineInfo;
	final rangeStart = range != null ? toOffset(lineInfo, range.start) : null;
	final rangeEnd = range != null ? toOffset(lineInfo, range.end) : null;

	if (rangeStart != null && rangeStart.isError) {
	return failure(rangeStart);
	}
	if (rangeEnd != null && rangeEnd.isError) {
	return failure(rangeEnd);
	}

	// It shouldn't be the case that we can't parse the code but if it happens
	// fall back to a full replacement rather than fail.
	final parsedFormatted = _parse(formatted, result.unit.featureSet);
	final parsedUnformatted = _parse(unformatted, result.unit.featureSet);
	if (parsedFormatted == null \|\| parsedUnformatted == null) {
	return success(_generateFullEdit(lineInfo, unformatted, formatted));
	}

	final unformattedTokens = _iterateAllTokens(parsedUnformatted).iterator;
	final formattedTokens = _iterateAllTokens(parsedFormatted).iterator;

	var unformattedOffset = 0;
	var formattedOffset = 0;
	final edits = <TextEdit>[];

	/// Helper for comparing whitespace and appending an edit.
	void addEditFor(
	int unformattedStart,
	int unformattedEnd,
	int formattedStart,
	int formattedEnd,
	) {
	final unformattedWhitespace =
	unformatted.substring(unformattedStart, unformattedEnd);
	final formattedWhitespace =
	formatted.substring(formattedStart, formattedEnd);

	if (rangeStart != null && rangeEnd != null) {
	// If this change crosses over the start of the requested range, discarding
	// the change may result in leading whitespace of the next line not being
	// formatted correctly.
	//
	// To handle this, if both unformatted/formatted contain at least one
	// newline, split this change into two around the last newline so that the
	// final part (likely leading whitespace) can be included without
	// including the whole change. This cannot be done if the newline is at
	// the end of the source whitespace though, as this would create a split
	// where the first part is the same and the second part is empty,
	// resulting in an infinite loop/stack overflow.
	//
	// Without this, functionality like VS Code's "format modified lines"
	// (which uses Git status to know which lines are edited) may appear to
	// fail to format the first newly added line in a range.
	if (unformattedStart < rangeStart.result &&
	unformattedEnd > rangeStart.result &&
	unformattedWhitespace.contains('\n') &&
	formattedWhitespace.contains('\n') &&
	!unformattedWhitespace.endsWith('\n')) {
	// Find the offsets of the character after the last newlines.
	final unformattedOffset = unformattedWhitespace.lastIndexOf('\n') + 1;
	final formattedOffset = formattedWhitespace.lastIndexOf('\n') + 1;
	// Call us again for the leading part
	addEditFor(
	unformattedStart,
	unformattedStart + unformattedOffset,
	formattedStart,
	formattedStart + formattedOffset,
	);
	// Call us again for the trailing part
	addEditFor(
	unformattedStart + unformattedOffset,
	unformattedEnd,
	formattedStart + formattedOffset,
	formattedEnd,
	);
	return;
	}

	// If we're formatting only a range, skip over any segments that don't fall
	// entirely within that range.
	if (unformattedStart < rangeStart.result \|\|
	unformattedEnd > rangeEnd.result) {
	return;
	}
	}

	if (unformattedWhitespace == formattedWhitespace) {
	return;
	}

	// Validate we didn't find more than whitespace. If this occurs, it's likely
	// the token offsets used were incorrect. In this case it's better to not
	// modify the code than potentially remove something important.
	if (unformattedWhitespace.trim().isNotEmpty \|\|
	formattedWhitespace.trim().isNotEmpty) {
	return;
	}

	var startOffset = unformattedStart;
	var endOffset = unformattedEnd;
	var newText = formattedWhitespace;

	// Simplify some common cases where the new whitespace is a subset of
	// the old.
	if (formattedWhitespace.isNotEmpty) {
	if (unformattedWhitespace.startsWith(formattedWhitespace)) {
	startOffset = unformattedStart + formattedWhitespace.length;
	newText = '';
	} else if (unformattedWhitespace.endsWith(formattedWhitespace)) {
	endOffset = unformattedEnd - formattedWhitespace.length;
	newText = '';
	}
	}

	// Finally, append the edit for this whitespace.
	// Note: As with all LSP edits, offsets are based on the original location
	// as they are applied in one shot. They should not account for the previous
	// edits in the same set.
	edits.add(TextEdit(
	range: Range(
	start: toPosition(lineInfo.getLocation(startOffset)),
	end: toPosition(lineInfo.getLocation(endOffset)),
	),
	newText: newText,
	));
	}

	// Process the whitespace before each token.
	bool unformattedHasMore, formattedHasMore;
	while ((unformattedHasMore =
	unformattedTokens.moveNext()) & // Don't short-circuit
	(formattedHasMore = formattedTokens.moveNext())) {
	final unformattedToken = unformattedTokens.current;
	final formattedToken = formattedTokens.current;

	if (unformattedToken.lexeme != formattedToken.lexeme) {
	// If the token lexems do not match, there is a difference in the parsed
	// token streams (this should not ordinarily happen) so fall back to a
	// full edit.
	return success(_generateFullEdit(lineInfo, unformatted, formatted));
	}

	addEditFor(
	unformattedOffset,
	unformattedToken.offset,
	formattedOffset,
	formattedToken.offset,
	);

	// When range formatting, if we've processed a token that ends after the
	// range then there can't be any more relevant edits and we can return early.
	if (rangeEnd != null && unformattedToken.end > rangeEnd.result) {
	return success(edits);
	}

	unformattedOffset = unformattedToken.end;
	formattedOffset = formattedToken.end;
	}

	// If we got here and either of the streams still have tokens, something
	// did not match so fall back to a full edit.
	if (unformattedHasMore \|\| formattedHasMore) {
	return success(_generateFullEdit(lineInfo, unformatted, formatted));
	}

	// Finally, handle any whitespace that was after the last token.
	addEditFor(
	unformattedOffset,
	unformatted.length,
	formattedOffset,
	formatted.length,
	);

	return success(edits);
	}

	/// Iterates over a token stream returning all tokens including comments.
	Iterable<Token> _iterateAllTokens(Token token) sync* {
	while (token.type != TokenType.EOF) {
	Token? commentToken = token.precedingComments;
	while (commentToken != null) {
	yield commentToken;
	commentToken = commentToken.next;
	}
	yield token;
	token = token.next!;
	}
	}

	/// Parse and return the first of the given Dart source, `null` if code cannot
	/// be parsed.
	Token? _parse(String s, FeatureSet featureSet) {
	try {
	var scanner = Scanner(_SourceMock.instance, CharSequenceReader(s),
	AnalysisErrorListener.NULL_LISTENER)
	..configureFeatures(
	featureSetForOverriding: featureSet,
	featureSet: featureSet,
	);
	return scanner.tokenize();
	} catch (e) {
	return null;
	}
	}

	/// Helper class that bundles up all information required when converting server
	/// SourceEdits into LSP-compatible WorkspaceEdits.
	class FileEditInformation {
	final OptionalVersionedTextDocumentIdentifier doc;
	final LineInfo lineInfo;
	final List<server.SourceEdit> edits;
	final bool newFile;

	/// The selection offset, relative to the edit.
	final int? selectionOffsetRelative;
	final int? selectionLength;

	FileEditInformation(this.doc, this.lineInfo, this.edits,
	{this.newFile = false,
	this.selectionOffsetRelative,
	this.selectionLength});
	}

	class _SourceMock implements Source {
	static final Source instance = _SourceMock();

	@override
	dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
	}