[analyzer_testing] Duplicates ExpectedContextMessage to start migrating

This is a first step towards migrating and merging tests helper classes to one central location. In a following CL, the old `ExpectedError` and `ExpectedContextMessage` will be removed and all clients will be migrated to the version under this package.

Bug: #61557
Change-Id: I7fb8a83cbd659192a22848ace99ebafed5dc2b88
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/451542
Commit-Queue: Paul Berry <[email protected]>
Auto-Submit: Felipe Morschel <[email protected]>
Reviewed-by: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: FMorschel

pkg/analyzer_testing/api.txt

@@ -1,12 +1,13 @@
 package:analyzer_testing/analysis_rule/analysis_rule.dart:
-  error (function: ExpectedDiagnostic Function(DiagnosticCode, int, int, {Pattern? messageContains}))
+  contextMessage (function: ExpectedContextMessage Function(File, int, int, {String? text, List<Pattern> textContains}))
+  error (function: ExpectedDiagnostic Function(DiagnosticCode, int, int, {List<ExpectedContextMessage>? contextMessages, Pattern? correctionContains, Pattern? messageContains}))
   AnalysisRuleTest (class extends PubPackageResolutionTest):
     new (constructor: AnalysisRuleTest Function())
     analysisRule (getter: String)
     assertNoPubspecDiagnostics (method: Future<void> Function(String))
     assertPubspecDiagnostics (method: Future<void> Function(String, List<ExpectedDiagnostic>))
     correctionMessage (method: String Function(List<Diagnostic>))
-    lint (method: ExpectedDiagnostic Function(int, int, {Pattern? correctionContains, Pattern? messageContains, String? name}))
+    lint (method: ExpectedDiagnostic Function(int, int, {List<ExpectedContextMessage>? contextMessages, Pattern? correctionContains, Pattern? messageContains, String? name}))
     setUp (method: void Function())
     unexpectedMessage (method: String Function(List<Diagnostic>))
 package:analyzer_testing/experiments/experiments.dart:
@@ -60,6 +61,7 @@ package:analyzer_testing/resource_provider_mixin.dart:
     toUri (method: Uri Function(String))
     toUriStr (method: String Function(String))
 package:analyzer_testing/src/analysis_rule/pub_package_resolution.dart:
+  ExpectedContextMessage (non-public)
   ExpectedDiagnostic (non-public)
   PubPackageResolutionTest (non-public)
 package:analyzer_testing/utilities/extensions/resource_provider.dart:

pkg/analyzer_testing/lib/analysis_rule/analysis_rule.dart

@@ -12,13 +12,28 @@ import 'package:analyzer/analysis_rule/pubspec.dart';
 import 'package:analyzer/diagnostic/diagnostic.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/file_source.dart';
 import 'package:analyzer/src/lint/pub.dart'; // ignore: implementation_imports
 import 'package:analyzer/src/lint/registry.dart'; // ignore: implementation_imports
 import 'package:analyzer_testing/src/analysis_rule/pub_package_resolution.dart';
 import 'package:analyzer_testing/utilities/utilities.dart';
 import 'package:meta/meta.dart';
 
+ExpectedContextMessage contextMessage(
+  File file,
+  int offset,
+  int length, {
+  String? text,
+  List<Pattern> textContains = const [],
+}) => ExpectedContextMessage(
+  file,
+  offset,
+  length,
+  text: text,
+  textContains: textContains,
+);
+
 /// Returns an [ExpectedDiagnostic] with the given arguments.
 ///
 /// Just a short-named helper for use in the `assert*Diagnostics` methods.
@@ -27,7 +42,16 @@ ExpectedDiagnostic error(
   int offset,
   int length, {
   Pattern? messageContains,
-}) => ExpectedError(code, offset, length, messageContains: messageContains);
+  Pattern? correctionContains,
+  List<ExpectedContextMessage>? contextMessages,
+}) => ExpectedError(
+  code,
+  offset,
+  length,
+  messageContains: messageContains,
+  correctionContains: correctionContains,
+  contextMessages: contextMessages,
+);
 
 /// A base class for analysis rule tests that use test_reflective_loader.
 abstract class AnalysisRuleTest extends PubPackageResolutionTest {
@@ -91,12 +115,14 @@ abstract class AnalysisRuleTest extends PubPackageResolutionTest {
     Pattern? messageContains,
     Pattern? correctionContains,
     String? name,
+    List<ExpectedContextMessage>? contextMessages,
   }) => ExpectedLint(
     name ?? analysisRule,
     offset,
     length,
     messageContains: messageContains,
     correctionContains: correctionContains,
+    contextMessages: contextMessages,
   );
 
   @mustCallSuper

pkg/analyzer_testing/lib/src/analysis_rule/pub_package_resolution.dart

@@ -25,15 +25,66 @@ import 'package:test/test.dart';
 
 typedef DiagnosticMatcher = bool Function(Diagnostic diagnostic);
 
+/// A description of a message that is expected to be reported with an error.
+class ExpectedContextMessage {
+  /// The path of the file with which the message is associated.
+  final File file;
+
+  /// The offset of the beginning of the error's region.
+  final int offset;
+
+  /// The offset of the beginning of the error's region.
+  final int length;
+
+  /// The message text for the error.
+  final String? text;
+
+  /// A list of patterns that should be contained in the message test; empty if
+  /// the message contents should not be checked.
+  final List<Pattern> textContains;
+
+  ExpectedContextMessage(
+    this.file,
+    this.offset,
+    this.length, {
+    this.text,
+    this.textContains = const [],
+  });
+
+  /// Return `true` if the [message] matches this description of what it's
+  /// expected to be.
+  bool matches(DiagnosticMessage message) {
+    if (message.filePath != file.path) {
+      return false;
+    }
+    if (message.offset != offset) {
+      return false;
+    }
+    if (message.length != length) {
+      return false;
+    }
+    var messageText = message.messageText(includeUrl: true);
+    if (text != null && messageText != text) {
+      return false;
+    }
+    for (var pattern in textContains) {
+      if (!messageText.contains(pattern)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
 /// A description of a diagnostic that is expected to be reported.
 class ExpectedDiagnostic {
-  final DiagnosticMatcher _diagnosticMatcher;
+  final DiagnosticMatcher diagnosticMatcher;
 
   /// The offset of the beginning of the diagnostic's region.
-  final int _offset;
+  final int offset;
 
   /// The length of the diagnostic's region.
-  final int _length;
+  final int length;
 
   /// A pattern that should be contained in the diagnostic message or `null` if
   /// the message contents should not be checked.
@@ -43,20 +94,26 @@ class ExpectedDiagnostic {
   /// `null` if the correction message contents should not be checked.
   final Pattern? _correctionContains;
 
+  /// The list of context messages that are expected to be associated with the
+  /// error, or `null` if the context messages should not be checked.
+  final List<ExpectedContextMessage>? _contextMessages;
+
   ExpectedDiagnostic(
-    this._diagnosticMatcher,
-    this._offset,
-    this._length, {
+    this.diagnosticMatcher,
+    this.offset,
+    this.length, {
     Pattern? messageContains,
     Pattern? correctionContains,
-  }) : _messageContains = messageContains,
+    List<ExpectedContextMessage>? contextMessages,
+  }) : _contextMessages = contextMessages,
+       _messageContains = messageContains,
        _correctionContains = correctionContains;
 
   /// Whether the [diagnostic] matches this description of what it's expected to be.
   bool matches(Diagnostic diagnostic) {
-    if (!_diagnosticMatcher(diagnostic)) return false;
-    if (diagnostic.offset != _offset) return false;
-    if (diagnostic.length != _length) return false;
+    if (!diagnosticMatcher(diagnostic)) return false;
+    if (diagnostic.offset != offset) return false;
+    if (diagnostic.length != length) return false;
     if (_messageContains != null &&
         !diagnostic.message.contains(_messageContains)) {
       return false;
@@ -68,6 +125,17 @@ class ExpectedDiagnostic {
         return false;
       }
     }
+    if (_contextMessages != null) {
+      var actualContextMessages = diagnostic.contextMessages.toList();
+      if (actualContextMessages.length != _contextMessages.length) {
+        return false;
+      }
+      for (int i = 0; i < _contextMessages.length; i++) {
+        if (!_contextMessages[i].matches(actualContextMessages[i])) {
+          return false;
+        }
+      }
+    }
 
     return true;
   }
@@ -77,13 +145,18 @@ class ExpectedDiagnostic {
 final class ExpectedError extends ExpectedDiagnostic {
   final DiagnosticCode _code;
 
-  ExpectedError(this._code, int offset, int length, {Pattern? messageContains})
-    : super(
-        (error) => error.diagnosticCode == _code,
-        offset,
-        length,
-        messageContains: messageContains,
-      );
+  ExpectedError(
+    this._code,
+    int offset,
+    int length, {
+    super.messageContains,
+    super.correctionContains,
+    super.contextMessages,
+  }) : super(
+         (diagnostic) => diagnostic.diagnosticCode == _code,
+         offset,
+         length,
+       );
 }
 
 /// A description of an expected lint rule violation.
@@ -96,7 +169,12 @@ final class ExpectedLint extends ExpectedDiagnostic {
     int length, {
     super.messageContains,
     super.correctionContains,
-  }) : super((error) => error.diagnosticCode.name == _lintName, offset, length);
+    super.contextMessages,
+  }) : super(
+         (diagnostic) => diagnostic.diagnosticCode.name == _lintName,
+         offset,
+         length,
+       );
 }
 
 class PubPackageResolutionTest with MockPackagesMixin, ResourceProviderMixin {
@@ -111,6 +189,9 @@ class PubPackageResolutionTest with MockPackagesMixin, ResourceProviderMixin {
 
   AnalysisContextCollectionImpl? _analysisContextCollection;
 
+  /// The test file being analyzed.
+  late File testFile = newFile(_testFilePath, '');
+
   /// The analysis result that is used in various `assertDiagnostics` methods.
   late ResolvedUnitResult result;
 
@@ -331,7 +412,18 @@ class PubPackageResolutionTest with MockPackagesMixin, ResourceProviderMixin {
       } else {
         buffer.write('  error(${actual.diagnosticCode}, ');
       }
-      buffer.write('${actual.offset}, ${actual.length}),');
+      buffer.write('${actual.offset}, ${actual.length},');
+      if (actual.contextMessages.isNotEmpty) {
+        buffer.write(' contextMessages: [');
+        for (var contextMessage in actual.contextMessages) {
+          buffer.write('contextMessage(');
+          buffer.write("newFile('${contextMessage.filePath}'), ");
+          buffer.write('${contextMessage.offset}, ${contextMessage.length},');
+          buffer.write('), ');
+        }
+        buffer.write('],');
+      }
+      buffer.write('),');
     }
 
     return buffer.toString();
@@ -351,8 +443,8 @@ class PubPackageResolutionTest with MockPackagesMixin, ResourceProviderMixin {
       if (expected is ExpectedLint) {
         buffer.write(expected._lintName);
       }
-      buffer.write(' [${expected._offset}, ');
-      buffer.write(expected._length);
+      buffer.write(' [${expected.offset}, ');
+      buffer.write(expected.length);
       if (expected._messageContains case Pattern messageContains) {
         buffer.write(', messageContains: ');
         buffer.write(json.encode(messageContains.toString()));
@@ -484,7 +576,7 @@ class PubPackageResolutionTest with MockPackagesMixin, ResourceProviderMixin {
   }
 
   void _addTestFile(String content) {
-    newFile(_testFilePath, content);
+    testFile.writeAsStringSync(content);
   }
 
   DriverBasedAnalysisContext _contextFor(String path) {