Version 3.4.0-168.0.dev

Merge 8b543ef into dev

pkg/analysis_server/lib/src/computer/computer_overrides.dart

@@ -136,6 +136,7 @@ class _OverriddenElementsFinder {
 
   /// Add the [OverriddenElements] for this element.
   OverriddenElements find() {
+    _class = _class.augmented?.declaration ?? _class;
     _visited.clear();
     _addSuperOverrides(_class, withThisType: false);
     _visited.clear();

pkg/analysis_server/lib/src/services/correction/fix/data_driven/code_fragment_parser.dart

@@ -80,8 +80,14 @@ class CodeFragmentParser {
         }
         accessors.add(accessor);
       } else {
-        errorReporter.reportErrorForOffset(TransformSetErrorCode.wrongToken,
-            token.offset + delta, token.length, ['.', token.kind.displayName]);
+        errorReporter.atOffset(
+          offset: token.offset + delta,
+          length: token.length,
+          errorCode: TransformSetErrorCode.wrongToken,
+          arguments: ['.', token.kind.displayName],
+          contextMessages: null,
+          data: null,
+        );
         return null;
       }
     }
@@ -106,8 +112,14 @@ class CodeFragmentParser {
     var expression = _parseLogicalAndExpression();
     if (currentIndex < _tokens.length) {
       var token = _tokens[currentIndex];
-      errorReporter.reportErrorForOffset(TransformSetErrorCode.unexpectedToken,
-          token.offset + delta, token.length, [token.kind.displayName]);
+      errorReporter.atOffset(
+        offset: token.offset + delta,
+        length: token.length,
+        errorCode: TransformSetErrorCode.unexpectedToken,
+        arguments: [token.kind.displayName],
+        contextMessages: null,
+        data: null,
+      );
       return null;
     }
     return expression;
@@ -140,16 +152,25 @@ class CodeFragmentParser {
         offset = last.offset;
         length = last.length;
       }
-      errorReporter.reportErrorForOffset(TransformSetErrorCode.missingToken,
-          offset + delta, length, [validKindsDisplayString()]);
+      errorReporter.atOffset(
+        offset: offset + delta,
+        length: length,
+        errorCode: TransformSetErrorCode.missingToken,
+        arguments: [validKindsDisplayString()],
+        contextMessages: null,
+        data: null,
+      );
       return null;
     }
     if (!validKinds.contains(token.kind)) {
-      errorReporter.reportErrorForOffset(
-          TransformSetErrorCode.wrongToken,
-          token.offset + delta,
-          token.length,
-          [validKindsDisplayString(), token.kind.displayName]);
+      errorReporter.atOffset(
+        offset: token.offset + delta,
+        length: token.length,
+        errorCode: TransformSetErrorCode.wrongToken,
+        arguments: [validKindsDisplayString(), token.kind.displayName],
+        contextMessages: null,
+        data: null,
+      );
       return null;
     }
     return token;
@@ -217,8 +238,14 @@ class CodeFragmentParser {
       advance();
       return TypeArgumentAccessor(argumentIndex);
     } else {
-      errorReporter.reportErrorForOffset(TransformSetErrorCode.unknownAccessor,
-          token.offset + delta, token.length, [identifier]);
+      errorReporter.atOffset(
+        offset: token.offset + delta,
+        length: token.length,
+        errorCode: TransformSetErrorCode.unknownAccessor,
+        arguments: [identifier],
+        contextMessages: null,
+        data: null,
+      );
       return null;
     }
   }
@@ -293,11 +320,14 @@ class CodeFragmentParser {
         var variableName = token.lexeme;
         var generator = variableScope.lookup(variableName);
         if (generator == null) {
-          errorReporter.reportErrorForOffset(
-              TransformSetErrorCode.undefinedVariable,
-              token.offset + delta,
-              token.length,
-              [variableName]);
+          errorReporter.atOffset(
+            offset: token.offset + delta,
+            length: token.length,
+            errorCode: TransformSetErrorCode.undefinedVariable,
+            arguments: [variableName],
+            contextMessages: null,
+            data: null,
+          );
           return null;
         }
         return VariableReference(generator);
@@ -323,8 +353,14 @@ class CodeFragmentParser {
       offset = token.offset + delta;
       length = token.length;
     }
-    errorReporter.reportErrorForOffset(
-        TransformSetErrorCode.expectedPrimary, offset, length);
+    errorReporter.atOffset(
+      offset: offset,
+      length: length,
+      errorCode: TransformSetErrorCode.expectedPrimary,
+      arguments: null,
+      contextMessages: null,
+      data: null,
+    );
     return null;
   }
 }
@@ -454,8 +490,14 @@ class _CodeFragmentScanner {
 
   /// Report the presence of an invalid character at the given [offset].
   Null _reportInvalidCharacter(int offset) {
-    errorReporter.reportErrorForOffset(TransformSetErrorCode.invalidCharacter,
-        offset + delta, 1, [content.substring(offset, offset + 1)]);
+    errorReporter.atOffset(
+      offset: offset + delta,
+      length: 1,
+      errorCode: TransformSetErrorCode.invalidCharacter,
+      arguments: [content.substring(offset, offset + 1)],
+      contextMessages: null,
+      data: null,
+    );
     return null;
   }
 

pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart

@@ -190,22 +190,29 @@ class TransformSetParser {
       }
       var endIndex = template.indexOf(_closeComponent, variableStart + 2);
       if (endIndex < 0) {
-        errorReporter.reportErrorForOffset(
-            TransformSetErrorCode.missingTemplateEnd,
-            templateOffset + variableStart,
-            2);
+        errorReporter.atOffset(
+          offset: templateOffset + variableStart,
+          length: 2,
+          errorCode: TransformSetErrorCode.missingTemplateEnd,
+          arguments: null,
+          contextMessages: null,
+          data: null,
+        );
         // Ignore the invalid component, treating it as if it extended to the
         // end of the template.
         return components;
       } else {
         var name = template.substring(variableStart + 2, endIndex).trim();
         var generator = variableScope.lookup(name);
         if (generator == null) {
-          errorReporter.reportErrorForOffset(
-              TransformSetErrorCode.undefinedVariable,
-              templateOffset + template.indexOf(name, variableStart),
-              name.length,
-              [name]);
+          errorReporter.atOffset(
+            offset: templateOffset + template.indexOf(name, variableStart),
+            length: name.length,
+            errorCode: TransformSetErrorCode.undefinedVariable,
+            arguments: [name],
+            contextMessages: null,
+            data: null,
+          );
           // Ignore the invalid component.
         } else {
           components.add(TemplateVariable(generator));
@@ -254,8 +261,14 @@ class TransformSetParser {
       var span = e.span;
       var offset = span?.start.offset ?? 0;
       var length = span?.length ?? 0;
-      errorReporter.reportErrorForOffset(
-          TransformSetErrorCode.yamlSyntaxError, offset, length, [e.message]);
+      errorReporter.atOffset(
+        offset: offset,
+        length: length,
+        errorCode: TransformSetErrorCode.yamlSyntaxError,
+        arguments: [e.message],
+        contextMessages: null,
+        data: null,
+      );
     }
     return null;
   }
@@ -266,8 +279,14 @@ class TransformSetParser {
   void _reportError(TransformSetErrorCode code, YamlNode node,
       [List<String> arguments = const []]) {
     var span = node.span;
-    errorReporter.reportErrorForOffset(
-        code, span.start.offset, span.length, arguments);
+    errorReporter.atOffset(
+      offset: span.start.offset,
+      length: span.length,
+      errorCode: code,
+      arguments: arguments,
+      contextMessages: null,
+      data: null,
+    );
   }
 
   /// Report that the value represented by the [node] does not have the

pkg/analysis_server/test/analysis/notification_overrides_test.dart

@@ -7,6 +7,7 @@ import 'dart:async';
 import 'package:analysis_server/protocol/protocol.dart';
 import 'package:analysis_server/protocol/protocol_constants.dart';
 import 'package:analysis_server/protocol/protocol_generated.dart';
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -60,6 +61,14 @@ class AnalysisNotificationOverridesTest extends PubPackageAnalysisServerTest {
     expect(member!.element.location!.offset, offset);
   }
 
+  /// Asserts that there is an overridden superclass [OverriddenMember] at the
+  /// offset of [search] in [override].
+  void assertHasSuperElementInFile(File file, String search) {
+    var offset = offsetInFile(file, search);
+    var member = overrideObject.superclassMember;
+    expect(member!.element.location!.offset, offset);
+  }
+
   /// Asserts that there are no overridden members from interfaces.
   void assertNoInterfaceMembers() {
     expect(overrideObject.interfaceMembers, isNull);
@@ -522,6 +531,50 @@ class C extends B {
     assertNoInterfaceMembers();
   }
 
+  Future<void> test_class_super_method_overriddenFromExtension() async {
+    var augmentation = newFile('$testPackageLibPath/a.dart', '''
+library augment 'test.dart';
+
+augment class A {
+  m() {} // in A
+}
+''');
+    addTestFile('''
+import augment 'a.dart';
+
+class A {}
+class B extends A {
+  m() {} // in B
+}
+''');
+    await prepareOverrides();
+    assertHasOverride('m() {} // in B');
+    assertHasSuperElementInFile(augmentation, 'm() {} // in A');
+    assertNoInterfaceMembers();
+  }
+
+  Future<void> test_class_super_method_overrideFromExtension() async {
+    var augmented = newFile('$testPackageLibPath/b.dart', '''
+import augment 'test.dart';
+
+class A {
+  m() {} // in A
+}
+class B extends A {}
+''');
+    addTestFile('''
+library augment 'b.dart';
+
+augment class B {
+  m() {} // in B
+}
+''');
+    await prepareOverrides();
+    assertHasOverride('m() {} // in B');
+    assertHasSuperElementInFile(augmented, 'm() {} // in A');
+    assertNoInterfaceMembers();
+  }
+
   Future<void> test_class_super_method_privateByPrivate() async {
     addTestFile('''
 class A {

pkg/analysis_server/test/edit/refactoring_test.dart

@@ -1668,6 +1668,23 @@ class A {
 ''');
   }
 
+  Future<void> test_class_macros() {
+    addTestFile('''
+import 'macros.dart';
+
+@DeclareInType('  /// named\\n  C.named();')
+class C {}
+''');
+    return assertSuccessfulRefactoring(() {
+      return sendRenameRequest('C {', 'NewName');
+    }, '''
+import 'macros.dart';
+
+@DeclareInType('  /// named\\n  C.named();')
+class NewName {}
+''');
+  }
+
   Future<void> test_class_method_in_objectPattern() {
     addTestFile('''
 void f(Object? x) {

pkg/analysis_server/test/integration/edit/get_refactoring_test.dart

@@ -65,4 +65,42 @@ void bar() {
     await analysisFinished;
     expect(currentAnalysisErrors[pathname], isEmpty);
   }
+
+  Future<void> test_rename_macro() async {
+    addMacros([declareInTypeMacro()]);
+    var pathname = sourcePath('lib/test.dart');
+    var text = r'''
+import 'macros.dart';
+
+@DeclareInType('  /// named\\n  C.named();')
+class C {}
+''';
+    writeFile(pathname, text);
+    await standardAnalysisSetup();
+    await analysisFinished;
+    expect(currentAnalysisErrors[pathname], isEmpty);
+
+    // expect a valid rename refactoring
+    var result = await sendEditGetRefactoring(
+        RefactoringKind.RENAME, pathname, text.indexOf('C {'), 0, false,
+        options: RenameOptions('Coo'));
+    expect(result.initialProblems, isEmpty);
+    expect(result.optionsProblems, isEmpty);
+    expect(result.finalProblems, isEmpty);
+    expect(result.potentialEdits, isNull);
+
+    var change = result.change!;
+    expect(change.edits.length, 1);
+    var fileEdit = change.edits.first;
+
+    // apply the refactoring, expect that the new code has no errors
+    expect(fileEdit.edits.length, 1);
+    for (var edit in fileEdit.edits) {
+      text = text.replaceRange(edit.offset, edit.end, edit.replacement);
+    }
+    await sendAnalysisUpdateContent({pathname: AddContentOverlay(text)});
+
+    await analysisFinished;
+    expect(currentAnalysisErrors[pathname], isEmpty);
+  }
 }