pkg/test_runner/lib/src/update_errors.dart - sdk - Git at Google

 // Copyright (c) 2019, 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:path/path.dart' as p;

 import 'static_error.dart';

 /// Matches end of leading indentation in a line.
 ///
 /// Only used on single lines.
 final _indentationRegExp = RegExp(r"(?=\S|$)");

 /// Matches a line that contains only a line comment.
 ///
 /// Only used on single lines.
 final _lineCommentRegExp = RegExp(r"^\s*//");

 /// Removes existing static error marker comments in [source] and adds markers
 /// for the given [errors].
 ///
 /// If [remove] is not empty, then only removes existing errors for the given
 /// sources. If [includeContext] is `true`, then includes context messages in
 /// the output. Otherwise discards them.
 String updateErrorExpectations(
   String path,
   String source,
   List<StaticError> errors, {
   Set<ErrorSource> remove = const {},
   bool includeContext = false,
   String? contextOwnerPath,
   Iterable<String> contextOwnerPaths = const [],
 }) {
   var currentPath = StaticError.normalizePath(path);
   var normalizedContextOwnerPaths = {
     if (contextOwnerPath != null) StaticError.normalizePath(contextOwnerPath),
     for (var path in contextOwnerPaths) StaticError.normalizePath(path),
   };
   var inputErrors = errors;
   var inputHasErrorsForCurrentPath = inputErrors.any(
     (error) =>
         error.path == currentPath ||
         error.contextMessages.any((context) => context.path == currentPath),
   );

   // Split the existing errors into kept and deleted lists.
   var existingParsed = StaticError.parseExpectationsUnattached(
     source: source,
     path: path,
   );
   var existingErrors = _attachLocalContexts(existingParsed);
   var keptErrors = <StaticError>[];
   var removedErrors = <StaticError>[];
   for (var error in existingErrors) {
     if (remove.contains(error.source)) {
       removedErrors.add(error);
     } else {
       keptErrors.add(error);
     }
   }

   var lines = List<String?>.of(source.split("\n"));

   // Keep track of the indentation on any existing expectation markers. If
   // found, it will try to preserve that indentation.
   var indentation = <int, int>{};

   // Remove all existing marker comments in the file, even for errors we are
   // preserving. We will regenerate marker comments for those errors too so
   // they can properly share location comments with new errors if needed.
   void removeLine(int line) {
     if (lines[line] == null) return;

     indentation[line] = _countIndentation(lines[line]!);

     // Null the line instead of removing it so that line numbers in the
     // reported errors are still correct.
     lines[line] = null;
   }

   for (var error in existingErrors) {
     error.sourceLines.forEach(removeLine);
     for (var contextMessage in error.contextMessages) {
       contextMessage.sourceLines.forEach(removeLine);
     }
   }

   if (normalizedContextOwnerPaths.isNotEmpty) {
     for (var context in existingParsed.contextMessages) {
       if (normalizedContextOwnerPaths.contains(context.contextOwnerPath)) {
         context.sourceLines.forEach(removeLine);
       }
     }
   }

   // Merge the new errors with the preserved ones.
   errors = [...inputErrors, ...keptErrors];

   // Group errors by the line where they appear.
   var errorMap = <int, List<StaticError>>{};
   for (var error in errors) {
     if (error.path == currentPath ||
         (!inputHasErrorsForCurrentPath && inputErrors.contains(error))) {
       // -1 to translate from one-based to zero-based index.
       errorMap.putIfAbsent(error.line - 1, () => []).add(error);
     }

     // Flatten out and include context messages.
     if (includeContext) {
       for (var context in error.contextMessages) {
         if (context.path == currentPath ||
             (!inputHasErrorsForCurrentPath && inputErrors.contains(error))) {
           // -1 to translate from one-based to zero-based index.
           errorMap.putIfAbsent(context.line - 1, () => []).add(context);
         }
       }
     }
   }

   var errorNumbers = _ErrorNumbers(errors);

   // If there are multiple errors on the same line, order them
   // deterministically. Context messages that share a location are ordered by
   // their numeric context number, not by message text.
   for (var errorList in errorMap.values) {
     errorList.sort((a, b) => _compareErrors(a, b, errorNumbers));
   }

   // Rebuild the source file a line at a time.
   var previousIndent = 0;
   var result = <String?>[];
   for (var i = 0; i < lines.length; i++) {
     // Keep the code.
     if (lines[i] != null) {
       result.add(lines[i]);
       previousIndent = _countIndentation(lines[i]!);
     }

     // Add expectations for any errors reported on this line.
     var errorsHere = errorMap[i];
     if (errorsHere == null) continue;

     var previousColumn = -1;
     var previousLength = -1;

     for (var error in errorsHere) {
       // Try to indent the line nicely to match the existing expectation that
       // is being regenerated. If that collides with the carets, then indent
       // the line based on the preceding line of code. If the caret still
       // doesn't fit with that indentation, we'll use an explicit location.
       var indent = indentation[i + 1];
       if (indent == null || error.column - 1 < indent + 2) {
         indent = previousIndent;
       }

       var comment = "${" " * indent}//";

       // Write the location line, unless we already have an identical one. Allow
       // sharing locations between errors with and without explicit lengths.
       if (error.column != previousColumn ||
           (previousLength != 0 &&
               error.length != 0 &&
               error.length != previousLength)) {
         // If the error location starts to the left of the line comment, or no
         // error length is specified, use an explicit location.
         if (error.column - 1 < indent + 2) {
           if (error.length == 0) {
             result.add("$comment [error column ${error.column}]");
           } else {
             result.add(
               "$comment [error column "
               "${error.column}, length ${error.length}]",
             );
           }
         } else {
           var spacing = " " * (error.column - 1 - 2 - indent);
           // A CFE-only error may not have a length, so treat it as length 1.
           var carets = "^" * (error.length == 0 ? 1 : error.length);
           result.add("$comment$spacing$carets");
         }
       }

       // If multiple errors share the same location, let them share a location
       // marker.
       previousColumn = error.column;
       previousLength = error.length;

       var errorLines = error.message.split("\n");
       var line = "$comment [${error.source.marker}";
       if (includeContext && errorNumbers.containsKey(error)) {
         line += " ${errorNumbers[error]}";
         if (error.isContext) {
           var owner = errorNumbers.ownerOf(error);
           if (owner != null && owner.path != error.path) {
             line += " for ${_markerPath(from: error.path, to: owner.path)}";
           }
         } else {
           var contextPaths = {
             for (var contextMessage in error.contextMessages)
               if (contextMessage.path != error.path) contextMessage.path,
           };
           if (contextPaths.isNotEmpty) {
             line +=
                 " see ${contextPaths.map((path) {
                   return _markerPath(from: error.path, to: path);
                 }).join(', ')}";
           }
         }
       }
       line += "] ${errorLines[0]}";
       result.add(line);
       for (var errorLine in errorLines.skip(1)) {
         result.add("$comment $errorLine");
       }

       // If the very next line in the source is a line comment, it would
       // become part of the inserted message. To prevent that, insert a blank
       // line.
       if (i < lines.length - 1 &&
           lines[i + 1] != null &&
           _lineCommentRegExp.hasMatch(lines[i + 1]!)) {
         result.add("");
       }
     }
   }

   return result.join("\n");
 }

 int _compareErrors(StaticError a, StaticError b, _ErrorNumbers errorNumbers) {
   if (a.isContext && b.isContext) {
     var aNumber = errorNumbers[a];
     var bNumber = errorNumbers[b];
     if (aNumber != null && bNumber != null && aNumber != bNumber) {
       return aNumber.compareTo(bNumber);
     }
   }

   return a.compareTo(b);
 }

 List<StaticError> _attachLocalContexts(ParsedStaticErrorExpectations parsed) {
   for (var error in parsed.errors) {
     var number = parsed.numberOf(error);
     if (number == null) continue;

     for (var context in parsed.contextMessages) {
       if (parsed.numberOf(context) == number &&
           context.contextOwnerPath == error.path &&
           context.path == error.path) {
         error.contextMessages.add(context);
       }
     }
   }

   return parsed.errors;
 }

 String _markerPath({required String from, required String to}) {
   return p.relative(to, from: p.dirname(from)).replaceAll(r'\', '/');
 }

 /// Manages the assignment of numeric IDs to errors and their context messages.
 ///
 /// When updating error expectations, errors that have context messages
 /// are assigned numbers to link them together (e.g., `[analyzer 1]`). This
 /// class tracks those assignments.
 ///
 /// Note: if the same context message appears multiple times at the same
 /// location, there will be distinct (non-identical) [StaticError] instances
 /// that compare equal. We use [Map.identity] to ensure that we can associate
 /// each with its own context number.
 class _ErrorNumbers {
   final _numbers = Map<StaticError, int>.identity();
   final _owners = Map<StaticError, StaticError>.identity();

   /// Assigns unique numbers to all [errors] that have context messages, as well
   /// as their context messages.
   factory _ErrorNumbers(List<StaticError> errors) {
     var result = _ErrorNumbers._();

     var nextNumberByOwner = <String, int>{};
     for (var error in errors) {
       if (error.contextMessages.isEmpty) continue;

       var number = nextNumberByOwner.update(
         error.path,
         (number) => number + 1,
         ifAbsent: () => 1,
       );

       result._numbers[error] = number;

       for (var context in error.contextMessages) {
         result._numbers[context] = number;
         result._owners[context] = error;
       }
     }

     return result;
   }

   _ErrorNumbers._();

   bool containsKey(StaticError error) => _numbers.containsKey(error);

   int? operator [](StaticError error) => _numbers[error];

   StaticError? ownerOf(StaticError context) => _owners[context];
 }

 /// Returns the number of characters of leading spaces in [line].
 int _countIndentation(String line) {
   var match = _indentationRegExp.firstMatch(line)!;
   return match.start;
 }
	// Copyright (c) 2019, 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:path/path.dart' as p;

	import 'static_error.dart';

	/// Matches end of leading indentation in a line.
	///
	/// Only used on single lines.
	final _indentationRegExp = RegExp(r"(?=\S\|$)");

	/// Matches a line that contains only a line comment.
	///
	/// Only used on single lines.
	final _lineCommentRegExp = RegExp(r"^\s*//");

	/// Removes existing static error marker comments in [source] and adds markers
	/// for the given [errors].
	///
	/// If [remove] is not empty, then only removes existing errors for the given
	/// sources. If [includeContext] is `true`, then includes context messages in
	/// the output. Otherwise discards them.
	String updateErrorExpectations(
	String path,
	String source,
	List<StaticError> errors, {
	Set<ErrorSource> remove = const {},
	bool includeContext = false,
	String? contextOwnerPath,
	Iterable<String> contextOwnerPaths = const [],
	}) {
	var currentPath = StaticError.normalizePath(path);
	var normalizedContextOwnerPaths = {
	if (contextOwnerPath != null) StaticError.normalizePath(contextOwnerPath),
	for (var path in contextOwnerPaths) StaticError.normalizePath(path),
	};
	var inputErrors = errors;
	var inputHasErrorsForCurrentPath = inputErrors.any(
	(error) =>
	error.path == currentPath \|\|
	error.contextMessages.any((context) => context.path == currentPath),
	);

	// Split the existing errors into kept and deleted lists.
	var existingParsed = StaticError.parseExpectationsUnattached(
	source: source,
	path: path,
	);
	var existingErrors = _attachLocalContexts(existingParsed);
	var keptErrors = <StaticError>[];
	var removedErrors = <StaticError>[];
	for (var error in existingErrors) {
	if (remove.contains(error.source)) {
	removedErrors.add(error);
	} else {
	keptErrors.add(error);
	}
	}

	var lines = List<String?>.of(source.split("\n"));

	// Keep track of the indentation on any existing expectation markers. If
	// found, it will try to preserve that indentation.
	var indentation = <int, int>{};

	// Remove all existing marker comments in the file, even for errors we are
	// preserving. We will regenerate marker comments for those errors too so
	// they can properly share location comments with new errors if needed.
	void removeLine(int line) {
	if (lines[line] == null) return;

	indentation[line] = _countIndentation(lines[line]!);

	// Null the line instead of removing it so that line numbers in the
	// reported errors are still correct.
	lines[line] = null;
	}

	for (var error in existingErrors) {
	error.sourceLines.forEach(removeLine);
	for (var contextMessage in error.contextMessages) {
	contextMessage.sourceLines.forEach(removeLine);
	}
	}

	if (normalizedContextOwnerPaths.isNotEmpty) {
	for (var context in existingParsed.contextMessages) {
	if (normalizedContextOwnerPaths.contains(context.contextOwnerPath)) {
	context.sourceLines.forEach(removeLine);
	}
	}
	}

	// Merge the new errors with the preserved ones.
	errors = [...inputErrors, ...keptErrors];

	// Group errors by the line where they appear.
	var errorMap = <int, List<StaticError>>{};
	for (var error in errors) {
	if (error.path == currentPath \|\|
	(!inputHasErrorsForCurrentPath && inputErrors.contains(error))) {
	// -1 to translate from one-based to zero-based index.
	errorMap.putIfAbsent(error.line - 1, () => []).add(error);
	}

	// Flatten out and include context messages.
	if (includeContext) {
	for (var context in error.contextMessages) {
	if (context.path == currentPath \|\|
	(!inputHasErrorsForCurrentPath && inputErrors.contains(error))) {
	// -1 to translate from one-based to zero-based index.
	errorMap.putIfAbsent(context.line - 1, () => []).add(context);
	}
	}
	}
	}

	var errorNumbers = _ErrorNumbers(errors);

	// If there are multiple errors on the same line, order them
	// deterministically. Context messages that share a location are ordered by
	// their numeric context number, not by message text.
	for (var errorList in errorMap.values) {
	errorList.sort((a, b) => _compareErrors(a, b, errorNumbers));
	}

	// Rebuild the source file a line at a time.
	var previousIndent = 0;
	var result = <String?>[];
	for (var i = 0; i < lines.length; i++) {
	// Keep the code.
	if (lines[i] != null) {
	result.add(lines[i]);
	previousIndent = _countIndentation(lines[i]!);
	}

	// Add expectations for any errors reported on this line.
	var errorsHere = errorMap[i];
	if (errorsHere == null) continue;

	var previousColumn = -1;
	var previousLength = -1;

	for (var error in errorsHere) {
	// Try to indent the line nicely to match the existing expectation that
	// is being regenerated. If that collides with the carets, then indent
	// the line based on the preceding line of code. If the caret still
	// doesn't fit with that indentation, we'll use an explicit location.
	var indent = indentation[i + 1];
	if (indent == null \|\| error.column - 1 < indent + 2) {
	indent = previousIndent;
	}

	var comment = "${" " * indent}//";

	// Write the location line, unless we already have an identical one. Allow
	// sharing locations between errors with and without explicit lengths.
	if (error.column != previousColumn \|\|
	(previousLength != 0 &&
	error.length != 0 &&
	error.length != previousLength)) {
	// If the error location starts to the left of the line comment, or no
	// error length is specified, use an explicit location.
	if (error.column - 1 < indent + 2) {
	if (error.length == 0) {
	result.add("$comment [error column ${error.column}]");
	} else {
	result.add(
	"$comment [error column "
	"${error.column}, length ${error.length}]",
	);
	}
	} else {
	var spacing = " " * (error.column - 1 - 2 - indent);
	// A CFE-only error may not have a length, so treat it as length 1.
	var carets = "^" * (error.length == 0 ? 1 : error.length);
	result.add("$comment$spacing$carets");
	}
	}

	// If multiple errors share the same location, let them share a location
	// marker.
	previousColumn = error.column;
	previousLength = error.length;

	var errorLines = error.message.split("\n");
	var line = "$comment [${error.source.marker}";
	if (includeContext && errorNumbers.containsKey(error)) {
	line += " ${errorNumbers[error]}";
	if (error.isContext) {
	var owner = errorNumbers.ownerOf(error);
	if (owner != null && owner.path != error.path) {
	line += " for ${_markerPath(from: error.path, to: owner.path)}";
	}
	} else {
	var contextPaths = {
	for (var contextMessage in error.contextMessages)
	if (contextMessage.path != error.path) contextMessage.path,
	};
	if (contextPaths.isNotEmpty) {
	line +=
	" see ${contextPaths.map((path) {
	return _markerPath(from: error.path, to: path);
	}).join(', ')}";
	}
	}
	}
	line += "] ${errorLines[0]}";
	result.add(line);
	for (var errorLine in errorLines.skip(1)) {
	result.add("$comment $errorLine");
	}

	// If the very next line in the source is a line comment, it would
	// become part of the inserted message. To prevent that, insert a blank
	// line.
	if (i < lines.length - 1 &&
	lines[i + 1] != null &&
	_lineCommentRegExp.hasMatch(lines[i + 1]!)) {
	result.add("");
	}
	}
	}

	return result.join("\n");
	}

	int _compareErrors(StaticError a, StaticError b, _ErrorNumbers errorNumbers) {
	if (a.isContext && b.isContext) {
	var aNumber = errorNumbers[a];
	var bNumber = errorNumbers[b];
	if (aNumber != null && bNumber != null && aNumber != bNumber) {
	return aNumber.compareTo(bNumber);
	}
	}

	return a.compareTo(b);
	}

	List<StaticError> _attachLocalContexts(ParsedStaticErrorExpectations parsed) {
	for (var error in parsed.errors) {
	var number = parsed.numberOf(error);
	if (number == null) continue;

	for (var context in parsed.contextMessages) {
	if (parsed.numberOf(context) == number &&
	context.contextOwnerPath == error.path &&
	context.path == error.path) {
	error.contextMessages.add(context);
	}
	}
	}

	return parsed.errors;
	}

	String _markerPath({required String from, required String to}) {
	return p.relative(to, from: p.dirname(from)).replaceAll(r'\', '/');
	}

	/// Manages the assignment of numeric IDs to errors and their context messages.
	///
	/// When updating error expectations, errors that have context messages
	/// are assigned numbers to link them together (e.g., `[analyzer 1]`). This
	/// class tracks those assignments.
	///
	/// Note: if the same context message appears multiple times at the same
	/// location, there will be distinct (non-identical) [StaticError] instances
	/// that compare equal. We use [Map.identity] to ensure that we can associate
	/// each with its own context number.
	class _ErrorNumbers {
	final _numbers = Map<StaticError, int>.identity();
	final _owners = Map<StaticError, StaticError>.identity();

	/// Assigns unique numbers to all [errors] that have context messages, as well
	/// as their context messages.
	factory _ErrorNumbers(List<StaticError> errors) {
	var result = _ErrorNumbers._();

	var nextNumberByOwner = <String, int>{};
	for (var error in errors) {
	if (error.contextMessages.isEmpty) continue;

	var number = nextNumberByOwner.update(
	error.path,
	(number) => number + 1,
	ifAbsent: () => 1,
	);

	result._numbers[error] = number;

	for (var context in error.contextMessages) {
	result._numbers[context] = number;
	result._owners[context] = error;
	}
	}

	return result;
	}

	_ErrorNumbers._();

	bool containsKey(StaticError error) => _numbers.containsKey(error);

	int? operator [](StaticError error) => _numbers[error];

	StaticError? ownerOf(StaticError context) => _owners[context];
	}

	/// Returns the number of characters of leading spaces in [line].
	int _countIndentation(String line) {
	var match = _indentationRegExp.firstMatch(line)!;
	return match.start;
	}