diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 409a7960651..0b76dddf53b 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -108,7 +108,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 624;
+  static const int DATA_VERSION = 626;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 4f4670a074a..5b783263c91 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -1986,6 +1986,12 @@ abstract class ElementImpl implements Element {
   @trackedIncludedInId
   final int id = FragmentImpl._NEXT_ID++;
 
+  /// The previous fragment with the same name in the library, but of a
+  /// different kind. Used for error reporting when an augmentation does not
+  /// match the kind of the declaration it augments.
+  @trackedIncludedInId
+  FragmentImpl? previousFragmentOfDifferentKind;
+
   /// The flags associated with this element.
   EnumSet<_ElementStorageFlag> _flags = EnumSet.empty();
 
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index f8362e84905..3c445a442f6 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -762,6 +762,10 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     covariant EnumConstantDeclarationImpl node,
   ) {
     _checkEnumConstantSameAsEnclosing(node);
+    _checkAugmentationWithoutDeclaration(
+      node.augmentKeyword,
+      node.declaredFragment!,
+    );
     _requiredParametersVerifier.visitEnumConstantDeclaration(node);
     _typeArgumentsVerifier.checkEnumConstantDeclaration(node);
     super.visitEnumConstantDeclaration(node);
@@ -1871,7 +1875,9 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
   }
 
   @override
-  void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+  void visitTopLevelVariableDeclaration(
+    covariant TopLevelVariableDeclarationImpl node,
+  ) {
     var variableList = node.variables;
 
     if (node.augmentKeyword case var augmentKeyword?) {
@@ -2007,13 +2013,39 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
 
   void _checkAugmentationWithoutDeclaration(
     Token? augmentKeyword,
-    Fragment fragment,
+    FragmentImpl fragment,
   ) {
     if (augmentKeyword != null) {
       if (fragment.previousFragment == null) {
-        diagnosticReporter.report(
-          diag.augmentationWithoutDeclaration.at(augmentKeyword),
-        );
+        var element = fragment.element;
+        if (element.previousFragmentOfDifferentKind case var previous?) {
+          diagnosticReporter.report(
+            diag.augmentationOfDifferentDeclarationKind
+                .withArguments(
+                  declarationKind: previous.element.kind.displayName,
+                  augmentationKind: element.kind.displayName,
+                )
+                .withContextMessages([
+                  if (previous case FragmentImpl(
+                    libraryFragment: var libraryFragment?,
+                    name: var name?,
+                    nameOffset: var nameOffset?,
+                  ))
+                    DiagnosticMessageImpl(
+                      filePath: libraryFragment.source.fullName,
+                      message: "The declaration being augmented.",
+                      offset: nameOffset,
+                      length: name.length,
+                      url: null,
+                    ),
+                ])
+                .at(augmentKeyword),
+          );
+        } else {
+          diagnosticReporter.report(
+            diag.augmentationWithoutDeclaration.at(augmentKeyword),
+          );
+        }
       }
     }
   }
diff --git a/pkg/analyzer/lib/src/summary2/bundle_reader.dart b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
index 4c12dafd5b4..4c0bf9122b9 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
@@ -261,6 +261,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<ClassFragmentImpl>();
       var element = ClassElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
 
       element.readFlags(_reader);
       element.hasNonFinalField = _reader.readBool();
@@ -344,6 +345,7 @@ class LibraryReader {
         firstFragment: fragments.first,
       );
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
 
       element.deferReadResolution(
@@ -457,6 +459,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<EnumFragmentImpl>();
       var element = EnumElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
       element.hasNonFinalField = _reader.readBool();
 
@@ -552,6 +555,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<ExtensionFragmentImpl>();
       var element = ExtensionElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
 
       _lazyRead((offset) {
@@ -618,6 +622,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<ExtensionTypeFragmentImpl>();
       var element = ExtensionTypeElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
 
       element.hasRepresentationSelfReference = _reader.readBool();
@@ -698,6 +703,7 @@ class LibraryReader {
         firstFragment: fragments.first,
       );
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
       element.typeInferenceError = _readTopLevelInferenceError();
 
@@ -834,6 +840,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<GetterFragmentImpl>();
       var element = GetterElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
 
       element.deferReadResolution(
@@ -1013,6 +1020,7 @@ class LibraryReader {
         firstFragment: fragments.first,
       );
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
       element.typeInferenceError = _readTopLevelInferenceError();
 
@@ -1069,6 +1077,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<MixinFragmentImpl>();
       var element = MixinElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
 
       element.readFlags(_reader);
       element.hasNonFinalField = _reader.readBool();
@@ -1150,6 +1159,10 @@ class LibraryReader {
     }
   }
 
+  FragmentImpl? _readOptionalFragmentById() {
+    return _reader.readOptionalObject(_readFragmentById);
+  }
+
   /// Read the reference of a non-local element.
   Reference? _readOptionalReference() {
     return _reader.readOptionalObject(() => _readReference());
@@ -1174,6 +1187,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<SetterFragmentImpl>();
       var element = SetterElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
 
       element.deferReadResolution(
@@ -1251,6 +1265,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<TopLevelFunctionFragmentImpl>();
       var element = TopLevelFunctionElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
 
       element.deferReadResolution(
@@ -1304,6 +1319,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<TopLevelVariableFragmentImpl>();
       var element = TopLevelVariableElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
+      element.previousFragmentOfDifferentKind = _readOptionalFragmentById();
       element.readFlags(_reader);
       element.typeInferenceError = _readTopLevelInferenceError();
 
diff --git a/pkg/analyzer/lib/src/summary2/bundle_writer.dart b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
index 60f26a68a18..0a7542f7c7e 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_writer.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
@@ -140,6 +140,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       _sink.writeBool(element.hasNonFinalField);
 
@@ -192,6 +193,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       assert(element.typeParameters.isEmpty);
 
@@ -262,6 +264,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       _sink.writeBool(element.hasNonFinalField);
 
@@ -329,6 +332,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
 
       _writeForLazyRead(() {
@@ -370,6 +374,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
 
       // TODO(fshcheglov): Put these separate flags into modifiers
@@ -425,6 +430,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       _sink._writeTopLevelInferenceError(element.typeInferenceError);
 
@@ -528,6 +534,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       assert(element.typeParameters.isEmpty);
 
@@ -618,6 +625,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       _sink._writeTopLevelInferenceError(element.typeInferenceError);
 
@@ -648,6 +656,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       _sink.writeBool(element.hasNonFinalField);
 
@@ -707,6 +716,10 @@ class BundleWriter {
     }
   }
 
+  void _writeOptionalFragmentId(FragmentImpl? fragment) {
+    _sink.writeOptionalObject(fragment, _writeFragmentId);
+  }
+
   void _writeOptionalReference(Reference? reference) {
     _sink.writeOptionalObject(reference, _writeReference);
   }
@@ -740,6 +753,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       assert(element.typeParameters.isEmpty);
 
@@ -775,6 +789,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
 
       _writeElementResolution(() {
@@ -805,6 +820,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
+      _writeOptionalFragmentId(element.previousFragmentOfDifferentKind);
       element.writeFlags(_sink);
       _sink._writeTopLevelInferenceError(element.typeInferenceError);
       _writeElementResolution(() {
diff --git a/pkg/analyzer/lib/src/summary2/element_builder.dart b/pkg/analyzer/lib/src/summary2/element_builder.dart
index a395f334b77..90f89ed34d7 100644
--- a/pkg/analyzer/lib/src/summary2/element_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/element_builder.dart
@@ -64,8 +64,20 @@ class ElementBuilder {
 
     for (var instanceEntry in elementChildFragments.entries) {
       var instanceElement = instanceEntry.key;
-      var lastFragments = <String?, FragmentImpl>{};
+      var lastInstanceFragments = <String?, FragmentImpl>{};
+      var lastStaticFragments = <String?, FragmentImpl>{};
       for (var fragment in instanceEntry.value) {
+        var isInStaticNamespace = switch (fragment) {
+          ConstructorFragmentImpl() => true,
+          FieldFragmentImpl(:var isStatic) => isStatic,
+          GetterFragmentImpl(:var isStatic) => isStatic,
+          SetterFragmentImpl(:var isStatic) => isStatic,
+          MethodFragmentImpl(:var isStatic) => isStatic,
+          _ => false,
+        };
+        var lastFragments = isInStaticNamespace
+            ? lastStaticFragments
+            : lastInstanceFragments;
         var lastFragment = lastFragments[fragment.name];
         switch (fragment) {
           case FieldFragmentImpl():
@@ -211,6 +223,10 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     libraryElement.addClass(element);
     libraryBuilder.declare(element, element.reference);
   }
@@ -243,6 +259,10 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     libraryElement.addEnum(element);
     libraryBuilder.declare(element, element.reference);
   }
@@ -275,6 +295,10 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     libraryElement.addExtension(element);
     libraryBuilder.declare(element, element.reference);
   }
@@ -307,6 +331,10 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     libraryElement.addExtensionType(element);
     libraryBuilder.declare(element, element.reference);
   }
@@ -346,6 +374,10 @@ class ElementBuilder {
       firstFragment: fragment,
     );
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     interfaceElement.addConstructor(element);
   }
 
@@ -389,6 +421,9 @@ class ElementBuilder {
       ),
       firstFragment: fieldFragment,
     );
+    if (fieldFragment.isAugmentation && lastFragment != null) {
+      fieldElement.previousFragmentOfDifferentKind = lastFragment;
+    }
     instanceElement.addField(fieldElement);
 
     {
@@ -462,6 +497,9 @@ class ElementBuilder {
       _addInstanceReference(instanceElement, '@getter', getterFragment.name),
       getterFragment,
     );
+    if (getterFragment.isAugmentation && lastFragment != null) {
+      getterElement.previousFragmentOfDifferentKind = lastFragment;
+    }
     instanceElement.addGetter(getterElement);
 
     // `class Enum {}` in `dart:core` declares `int get index` as abstract.
@@ -533,17 +571,21 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
-    instanceElement.addMethod(
-      MethodElementImpl(
-        name: fragment.name,
-        reference: _addInstanceReference(
-          instanceElement,
-          '@method',
-          fragment.lookupName,
-        ),
-        firstFragment: fragment,
+    var element = MethodElementImpl(
+      name: fragment.name,
+      reference: _addInstanceReference(
+        instanceElement,
+        '@method',
+        fragment.lookupName,
       ),
+      firstFragment: fragment,
     );
+
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
+    instanceElement.addMethod(element);
   }
 
   void _handleInstanceSetterFragment(
@@ -570,6 +612,9 @@ class ElementBuilder {
       _addInstanceReference(instanceElement, '@setter', setterFragment.name),
       setterFragment,
     );
+    if (setterFragment.isAugmentation && lastFragment != null) {
+      setterElement.previousFragmentOfDifferentKind = lastFragment;
+    }
     instanceElement.addSetter(setterElement);
 
     // If `setter` is already set, this is a compile-time error.
@@ -628,6 +673,10 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     libraryElement.addMixin(element);
     libraryBuilder.declare(element, element.reference);
   }
@@ -665,6 +714,10 @@ class ElementBuilder {
       TypeParameterElementImpl(firstFragment: typeParameter);
     }
 
+    if (fragment.isAugmentation && lastFragment != null) {
+      element.previousFragmentOfDifferentKind = lastFragment;
+    }
+
     libraryElement.addTopLevelFunction(element);
     libraryBuilder.declare(element, element.reference);
   }
@@ -690,6 +743,9 @@ class ElementBuilder {
       _addTopReference('@getter', getterFragment.name),
       getterFragment,
     );
+    if (getterFragment.isAugmentation && lastFragment != null) {
+      getterElement.previousFragmentOfDifferentKind = lastFragment;
+    }
     libraryElement.addGetter(getterElement);
     libraryBuilder.declare(getterElement, getterElement.reference);
 
@@ -740,6 +796,9 @@ class ElementBuilder {
       _addTopReference('@setter', setterFragment.name),
       setterFragment,
     );
+    if (setterFragment.isAugmentation && lastFragment != null) {
+      setterElement.previousFragmentOfDifferentKind = lastFragment;
+    }
     libraryElement.addSetter(setterElement);
     libraryBuilder.declare(setterElement, setterElement.reference);
 
@@ -787,6 +846,9 @@ class ElementBuilder {
       _addTopReference('@topLevelVariable', variableFragment.name),
       variableFragment,
     );
+    if (variableFragment.isAugmentation && lastFragment != null) {
+      variableElement.previousFragmentOfDifferentKind = lastFragment;
+    }
     libraryElement.addTopLevelVariable(variableElement);
 
     {
diff --git a/pkg/analyzer/test/src/diagnostics/augmentation_of_different_declaration_kind_test.dart b/pkg/analyzer/test/src/diagnostics/augmentation_of_different_declaration_kind_test.dart
index 84bb44cea79..121c26a3ecd 100644
--- a/pkg/analyzer/test/src/diagnostics/augmentation_of_different_declaration_kind_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/augmentation_of_different_declaration_kind_test.dart
@@ -9,652 +9,771 @@ import '../dart/resolution/context_collection_resolution.dart';
 
 main() {
   defineReflectiveSuite(() {
-    // TODO(scheglov): implement augmentation
-    // defineReflectiveTests(AugmentationOfDifferentDeclarationKindTest);
+    defineReflectiveTests(AugmentationOfDifferentDeclarationKindTest);
   });
 }
 
 @reflectiveTest
 class AugmentationOfDifferentDeclarationKindTest
     extends PubPackageResolutionTest {
-  test_class_augmentedBy_enum() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_enum() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment enum A {}
+enum A {v}
+augment class A {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 5, 1)],
+        ),
+      ],
     );
   }
 
-  test_class_augmentedBy_extension() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_extension() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment extension A {}
+extension A on int {}
+augment class A {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          22,
+          7,
+          contextMessages: [message(testFile, 10, 1)],
+        ),
+      ],
     );
   }
 
-  test_class_augmentedBy_extensionType() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_extensionType() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment extension type A(int it) {}
+extension type A(int it) {}
+augment class A {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          28,
+          7,
+          contextMessages: [message(testFile, 15, 1)],
+        ),
+      ],
     );
   }
 
-  test_class_augmentedBy_function() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_function() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment void A() {}
+void foo() {}
+augment class foo {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          14,
+          7,
+          contextMessages: [message(testFile, 5, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_augmentedBy_mixin() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_getter() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment mixin A {}
+int get foo => 0;
+augment class foo {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          18,
+          7,
+          contextMessages: [message(testFile, 8, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_augmentedBy_typedef() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_mixin() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment typedef A = int;
+mixin A {}
+augment class A {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
     );
   }
 
-  test_class_augmentedBy_variable() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {}
-''');
-
+  test_class_augments_setter() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment int A = 0;
+set foo(int _) {}
+augment class foo {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          18,
+          7,
+          contextMessages: [message(testFile, 4, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_constructor_augmentedBy_constructor() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_class_augments_variable() async {
+    await assertErrorsInCode(
+      r'''
+int foo = 0;
+augment class foo {}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          13,
+          7,
+          contextMessages: [message(testFile, 4, 3)],
+        ),
+      ],
+    );
+  }
 
+  test_class_constructor_augments_constructor() async {
+    await assertNoErrorsInCode(r'''
 class A {
   A.foo();
 }
-''');
-
-    await assertNoErrorsInCode(r'''
-part of 'a.dart';
-
 augment class A {
   augment A.foo();
 }
 ''');
   }
 
-  test_class_constructor_augmentedBy_field() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  A.foo();
-}
-''');
-
+  test_class_constructor_augments_staticField() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment class A {
-  augment int foo = 0;
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_constructor_augmentedBy_getter() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
 class A {
-  A.foo();
+  static int foo = 0;
 }
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class A {
-  augment int get foo => 0;
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_constructor_augmentedBy_method() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  A.foo();
-}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class A {
-  augment void foo() {}
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_constructor_augmentedBy_setter() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  A.foo();
-}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class A {
-  augment set foo(int _) {}
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_field_augmentedBy_constructor() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  int foo = 0;
-}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
 augment class A {
   augment A.foo();
 }
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          54,
+          7,
+          contextMessages: [message(testFile, 23, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_field_augmentedBy_field() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_class_constructor_augments_staticMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment A.foo();
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          55,
+          7,
+          contextMessages: [message(testFile, 24, 3)],
+        ),
+      ],
+    );
+  }
 
+  test_class_instanceField_augments_instanceField() async {
+    await assertNoErrorsInCode(r'''
 class A {
   int foo = 0;
 }
-''');
-
-    await assertNoErrorsInCode(r'''
-part of 'a.dart';
-
 augment class A {
   augment int foo = 1;
 }
 ''');
   }
 
-  test_class_field_augmentedBy_getter() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  int foo = 0;
-}
-''');
-
-    await assertNoErrorsInCode(r'''
-part of 'a.dart';
-
-augment class A {
-  augment int get foo => 0;
-}
-''');
-  }
-
-  test_class_field_augmentedBy_method() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  int foo = 0;
-}
-''');
-
+  test_class_instanceField_augments_instanceMethod() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment class A {
-  augment void foo() {}
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_field_augmentedBy_setter() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  int foo = 0;
-}
-''');
-
-    await assertNoErrorsInCode(r'''
-part of 'a.dart';
-
-augment class A {
-  augment set foo(int _) {}
-}
-''');
-  }
-
-  test_class_getter_augmentedBy_method() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  int get foo => 0;
-}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class A {
-  augment void foo() {}
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_method_augmentedBy_constructor() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
 class A {
   void foo() {}
 }
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class A {
-  augment A.foo();
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_class_method_augmentedBy_field() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-class A {
-  void foo() {}
-}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
 augment class A {
   augment int foo = 0;
 }
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          48,
+          7,
+          contextMessages: [message(testFile, 17, 3)],
+        ),
+        error(
+          diag.duplicateDefinition,
+          60,
+          3,
+          contextMessages: [message(testFile, 17, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_method_augmentedBy_getter() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_class_instanceGetter_augments_instanceField() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment int get foo => 0;
+}
+''');
+  }
 
+  test_class_instanceGetter_augments_instanceMethod() async {
+    await assertErrorsInCode(
+      r'''
 class A {
   void foo() {}
 }
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
 augment class A {
   augment int get foo => 0;
 }
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          48,
+          7,
+          contextMessages: [message(testFile, 17, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_method_augmentedBy_method() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_class_instanceMethod_augments_instanceField() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          47,
+          7,
+          contextMessages: [message(testFile, 16, 3)],
+        ),
+      ],
+    );
+  }
 
+  test_class_instanceMethod_augments_instanceGetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          52,
+          7,
+          contextMessages: [message(testFile, 20, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_instanceMethod_augments_instanceMethod() async {
+    await assertNoErrorsInCode(r'''
 class A {
   void foo() {}
 }
-''');
-
-    await assertNoErrorsInCode(r'''
-part of 'a.dart';
-
 augment class A {
   augment void foo() {}
 }
 ''');
   }
 
-  test_class_method_augmentedBy_setter() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_class_instanceMethod_augments_instanceSetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          52,
+          7,
+          contextMessages: [message(testFile, 16, 3)],
+        ),
+      ],
+    );
+  }
 
+  test_class_instanceSetter_augments_instanceField() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''');
+  }
+
+  test_class_instanceSetter_augments_instanceMethod() async {
+    await assertErrorsInCode(
+      r'''
 class A {
   void foo() {}
 }
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
 augment class A {
   augment set foo(int _) {}
 }
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          48,
+          7,
+          contextMessages: [message(testFile, 17, 3)],
+        ),
+      ],
     );
   }
 
-  test_class_setter_augmentedBy_method() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
+  test_class_staticField_augments_constructor() async {
+    await assertErrorsInCode(
+      r'''
 class A {
-  set foo(int _) {}
+  A.foo();
 }
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
 augment class A {
-  augment void foo() {}
+  augment static int foo = 0;
 }
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
+      [
+        error(diag.conflictingConstructorAndStaticField, 14, 3),
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          43,
+          7,
+          contextMessages: [message(testFile, 14, 3)],
+        ),
+      ],
     );
   }
 
-  test_enum_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-enum A {v}
-''');
-
+  test_class_staticField_augments_staticMethod() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment class A {}
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment static int foo = 0;
+}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          55,
+          7,
+          contextMessages: [message(testFile, 24, 3)],
+        ),
+        error(
+          diag.duplicateDefinition,
+          74,
+          3,
+          contextMessages: [message(testFile, 24, 3)],
+        ),
+      ],
     );
   }
 
-  test_enum_constant_augmentedBy_constant() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_class_staticGetter_augments_constructor() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          43,
+          7,
+          contextMessages: [message(testFile, 14, 3)],
+        ),
+      ],
+    );
+  }
 
+  test_class_staticGetter_augments_staticMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          55,
+          7,
+          contextMessages: [message(testFile, 24, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_staticMethod_augments_constructor() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          43,
+          7,
+          contextMessages: [message(testFile, 14, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_staticMethod_augments_staticField() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment static void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          54,
+          7,
+          contextMessages: [message(testFile, 23, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_staticMethod_augments_staticGetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment static void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          59,
+          7,
+          contextMessages: [message(testFile, 27, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_staticMethod_augments_staticSetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment static void foo() {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          59,
+          7,
+          contextMessages: [message(testFile, 23, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_staticSetter_augments_constructor() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          43,
+          7,
+          contextMessages: [message(testFile, 14, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_class_staticSetter_augments_staticMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          55,
+          7,
+          contextMessages: [message(testFile, 24, 3)],
+        ),
+      ],
+    );
+  }
+
+  test_enum_augments_class() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+augment enum A {}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
+    );
+  }
+
+  test_enum_constant_augments_constant() async {
+    await assertNoErrorsInCode(r'''
 enum A {
   foo
 }
-''');
-
-    await assertNoErrorsInCode(r'''
-part of 'a.dart';
-
 augment enum A {
   augment foo(),
 }
 ''');
   }
 
-  test_enum_constant_augmentedBy_method() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-enum A {
-  foo
-}
-''');
-
+  test_enum_constant_augments_instanceMethod() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment enum A {;
-  augment static void foo() {}
-}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 39, 7)],
-    );
-  }
-
-  test_enum_method_augmentedBy_constant() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
 enum A {
   v;
   void foo() {}
 }
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
 augment enum A {
   augment foo(),
 }
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 38, 7)],
+      [
+        error(diag.augmentationWithoutDeclaration, 51, 7),
+        error(diag.conflictingStaticAndInstance, 59, 3),
+      ],
     );
   }
 
-  test_extension_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-extension A on int {}
-''');
-
+  test_enum_staticMethod_augments_constant() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment class A {}
+enum A {
+  foo
+}
+augment enum A {;
+  augment static void foo() {}
+}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          37,
+          7,
+          contextMessages: [message(testFile, 11, 3)],
+        ),
+      ],
     );
   }
 
-  test_extensionType_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-extension type A(int it) {}
-''');
-
+  test_extension_augments_class() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment class A {}
+class A {}
+augment extension A {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
     );
   }
 
-  test_mixin_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-mixin A {}
-''');
-
+  test_extensionType_augments_class() async {
     await assertErrorsInCode(
       r'''
-part of 'a.dart';
-
-augment class A {}
+class A {}
+augment extension type A(int it) {}
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
     );
   }
 
-  test_topFunction_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
+  test_function_augments_class() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+augment void A() {}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
+    );
+  }
 
+  test_mixin_augments_class() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+augment mixin A {}
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
+    );
+  }
+
+  test_typedef_augments_class() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+augment typedef A = int;
+''',
+      [error(diag.typedefAugmentation, 11, 7)],
+    );
+  }
+
+  test_variable_augments_class() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+augment int A = 0;
+''',
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          11,
+          7,
+          contextMessages: [message(testFile, 6, 1)],
+        ),
+      ],
+    );
+  }
+
+  test_variable_augments_function() async {
+    await assertErrorsInCode(
+      r'''
 void foo() {}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class foo {}
+augment int foo = 0;
 ''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
-    );
-  }
-
-  test_topGetter_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-int get foo => 0;
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class foo {}
-''',
-      [error(diag.augmentationOfDifferentDeclarationKind, 19, 7)],
-    );
-  }
-
-  test_topSetter_augmentedBy_class() async {
-    newFile('$testPackageLibPath/a.dart', r'''
-part 'test.dart';
-
-set foo(int _) {}
-''');
-
-    await assertErrorsInCode(
-      r'''
-part of 'a.dart';
-
-augment class foo {}
-''',
-      [error(diag.augmentationWithoutDeclaration, 19, 7)],
+      [
+        error(
+          diag.augmentationOfDifferentDeclarationKind,
+          14,
+          7,
+          contextMessages: [message(testFile, 5, 3)],
+        ),
+      ],
     );
   }
 }
diff --git a/pkg/analyzer/test/src/diagnostics/augmentation_without_declaration_test.dart b/pkg/analyzer/test/src/diagnostics/augmentation_without_declaration_test.dart
index 55ea681d4ab..b8837bd4e1f 100644
--- a/pkg/analyzer/test/src/diagnostics/augmentation_without_declaration_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/augmentation_without_declaration_test.dart
@@ -24,6 +24,14 @@ augment class A {}
     );
   }
 
+  test_class_augments_class() async {
+    await assertNoErrorsInCode(r'''
+class A {}
+
+augment class A {}
+''');
+  }
+
   test_class_constructor() async {
     await assertErrorsInCode(
       r'''
@@ -37,7 +45,37 @@ augment class A {
     );
   }
 
-  test_class_field() async {
+  test_class_constructor_augments_instanceField() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  int foo = 0;
+}
+
+augment class A {
+  augment A.foo();
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 48, 7)],
+    );
+  }
+
+  test_class_constructor_augments_instanceMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  void foo() {}
+}
+
+augment class A {
+  augment A.foo();
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 49, 7)],
+    );
+  }
+
+  test_class_instanceField() async {
     await assertErrorsInCode(
       r'''
 class A {}
@@ -50,20 +88,22 @@ augment class A {
     );
   }
 
-  test_class_field_static() async {
+  test_class_instanceField_augments_constructor() async {
     await assertErrorsInCode(
       r'''
-class A {}
+class A {
+  A.foo();
+}
 
 augment class A {
-  augment static int foo = 0;
+  augment int foo = 0;
 }
 ''',
-      [error(diag.augmentationWithoutDeclaration, 32, 7)],
+      [error(diag.augmentationWithoutDeclaration, 44, 7)],
     );
   }
 
-  test_class_field_valid() async {
+  test_class_instanceField_augments_instanceField() async {
     await assertNoErrorsInCode(r'''
 class A {
   int foo = 0;
@@ -75,7 +115,48 @@ augment class A {
 ''');
   }
 
-  test_class_getter() async {
+  test_class_instanceField_augments_staticField() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment int foo = 0;
+}
+''',
+      [
+        error(diag.conflictingStaticAndInstance, 23, 3),
+        error(diag.augmentationWithoutDeclaration, 54, 7),
+      ],
+    );
+  }
+
+  test_class_instanceField_augments_staticGetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static int get foo => 0;',
+      augmentation: 'int foo = 0;',
+      conflictAtAugmentation: false,
+    );
+  }
+
+  test_class_instanceField_augments_staticMethod() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static void foo() {}',
+      augmentation: 'int foo = 0;',
+      conflictAtAugmentation: false,
+    );
+  }
+
+  test_class_instanceField_augments_staticSetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static set foo(int _) {}',
+      augmentation: 'int foo = 0;',
+      conflictAtAugmentation: false,
+    );
+  }
+
+  test_class_instanceGetter() async {
     await assertErrorsInCode(
       r'''
 class A {}
@@ -88,20 +169,60 @@ augment class A {
     );
   }
 
-  test_class_getter_static() async {
+  test_class_instanceGetter_augments_constructor() async {
     await assertErrorsInCode(
       r'''
-class A {}
+class A {
+  A.foo();
+}
 
 augment class A {
-  augment static int get foo => 0;
+  augment int get foo => 0;
 }
 ''',
-      [error(diag.augmentationWithoutDeclaration, 32, 7)],
+      [error(diag.augmentationWithoutDeclaration, 44, 7)],
     );
   }
 
-  test_class_method() async {
+  test_class_instanceGetter_augments_staticField() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static int foo = 0;',
+      augmentation: 'int get foo => 0;',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceGetter_augments_staticGetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment int get foo => 0;
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 59, 7)],
+    );
+  }
+
+  test_class_instanceGetter_augments_staticMethod() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static void foo() {}',
+      augmentation: 'int get foo => 0;',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceGetter_augments_staticSetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static set foo(int _) {}',
+      augmentation: 'int get foo => 0;',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceMethod() async {
     await assertErrorsInCode(
       r'''
 class A {}
@@ -114,20 +235,22 @@ augment class A {
     );
   }
 
-  test_class_method_static() async {
+  test_class_instanceMethod_augments_constructor() async {
     await assertErrorsInCode(
       r'''
-class A {}
+class A {
+  A.foo();
+}
 
 augment class A {
-  augment static void foo() {}
+  augment void foo() {}
 }
 ''',
-      [error(diag.augmentationWithoutDeclaration, 32, 7)],
+      [error(diag.augmentationWithoutDeclaration, 44, 7)],
     );
   }
 
-  test_class_method_valid() async {
+  test_class_instanceMethod_augments_instanceMethod() async {
     await assertNoErrorsInCode(r'''
 class A {
   void foo() {}
@@ -139,7 +262,45 @@ augment class A {
 ''');
   }
 
-  test_class_setter() async {
+  test_class_instanceMethod_augments_staticField() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static int foo = 0;',
+      augmentation: 'void foo() {}',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceMethod_augments_staticGetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static int get foo => 0;',
+      augmentation: 'void foo() {}',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceMethod_augments_staticMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment void foo() {}
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 55, 7)],
+    );
+  }
+
+  test_class_instanceMethod_augments_staticSetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static set foo(int _) {}',
+      augmentation: 'void foo() {}',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceSetter() async {
     await assertErrorsInCode(
       r'''
 class A {}
@@ -152,7 +313,213 @@ augment class A {
     );
   }
 
-  test_class_setter_static() async {
+  test_class_instanceSetter_augments_constructor() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  A.foo();
+}
+
+augment class A {
+  augment set foo(int _) {}
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 44, 7)],
+    );
+  }
+
+  test_class_instanceSetter_augments_staticField() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static int foo = 0;',
+      augmentation: 'set foo(int _) {}',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceSetter_augments_staticGetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static int get foo => 0;',
+      augmentation: 'set foo(int _) {}',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceSetter_augments_staticMethod() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'static void foo() {}',
+      augmentation: 'set foo(int _) {}',
+      expectConflict: false,
+    );
+  }
+
+  test_class_instanceSetter_augments_staticSetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 59, 7)],
+    );
+  }
+
+  test_class_staticField() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+
+augment class A {
+  augment static int foo = 0;
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 32, 7)],
+    );
+  }
+
+  test_class_staticField_augments_instanceField() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment static int foo = 0;
+}
+''',
+      [
+        error(diag.augmentationWithoutDeclaration, 47, 7),
+        error(diag.conflictingStaticAndInstance, 66, 3),
+      ],
+    );
+  }
+
+  test_class_staticField_augments_instanceGetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'int get foo => 0;',
+      augmentation: 'static int foo = 0;',
+    );
+  }
+
+  test_class_staticField_augments_instanceMethod() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'void foo() {}',
+      augmentation: 'static int foo = 0;',
+    );
+  }
+
+  test_class_staticField_augments_instanceSetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'set foo(int _) {}',
+      augmentation: 'static int foo = 0;',
+    );
+  }
+
+  test_class_staticGetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+
+augment class A {
+  augment static int get foo => 0;
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 32, 7)],
+    );
+  }
+
+  test_class_staticGetter_augments_instanceField() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'int foo = 0;',
+      augmentation: 'static int get foo => 0;',
+    );
+  }
+
+  test_class_staticGetter_augments_instanceGetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''',
+      [
+        error(diag.augmentationWithoutDeclaration, 52, 7),
+        error(diag.conflictingStaticAndInstance, 75, 3),
+      ],
+    );
+  }
+
+  test_class_staticGetter_augments_instanceMethod() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'void foo() {}',
+      augmentation: 'static int get foo => 0;',
+    );
+  }
+
+  test_class_staticGetter_augments_instanceSetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'set foo(int _) {}',
+      augmentation: 'static int get foo => 0;',
+    );
+  }
+
+  test_class_staticMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {}
+
+augment class A {
+  augment static void foo() {}
+}
+''',
+      [error(diag.augmentationWithoutDeclaration, 32, 7)],
+    );
+  }
+
+  test_class_staticMethod_augments_instanceField() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'int foo = 0;',
+      augmentation: 'static void foo() {}',
+    );
+  }
+
+  test_class_staticMethod_augments_instanceGetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'int get foo => 0;',
+      augmentation: 'static void foo() {}',
+    );
+  }
+
+  test_class_staticMethod_augments_instanceMethod() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  void foo() {}
+}
+augment class A {
+  augment static void foo() {}
+}
+''',
+      [
+        error(diag.augmentationWithoutDeclaration, 48, 7),
+        error(diag.conflictingStaticAndInstance, 68, 3),
+      ],
+    );
+  }
+
+  test_class_staticMethod_augments_instanceSetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'set foo(int _) {}',
+      augmentation: 'static void foo() {}',
+    );
+  }
+
+  test_class_staticSetter() async {
     await assertErrorsInCode(
       r'''
 class A {}
@@ -165,12 +532,42 @@ augment class A {
     );
   }
 
-  test_class_valid() async {
-    await assertNoErrorsInCode(r'''
-class A {}
+  test_class_staticSetter_augments_instanceField() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'int foo = 0;',
+      augmentation: 'static set foo(int _) {}',
+    );
+  }
 
-augment class A {}
-''');
+  test_class_staticSetter_augments_instanceGetter() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'int get foo => 0;',
+      augmentation: 'static set foo(int _) {}',
+    );
+  }
+
+  test_class_staticSetter_augments_instanceMethod() async {
+    await _assertClassMemberAugmentationWithoutDeclaration(
+      declaration: 'void foo() {}',
+      augmentation: 'static set foo(int _) {}',
+    );
+  }
+
+  test_class_staticSetter_augments_instanceSetter() async {
+    await assertErrorsInCode(
+      r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''',
+      [
+        error(diag.augmentationWithoutDeclaration, 52, 7),
+        error(diag.conflictingStaticAndInstance, 71, 3),
+      ],
+    );
   }
 
   test_enum() async {
@@ -201,7 +598,7 @@ augment enum A {;
     );
   }
 
-  test_enum_field() async {
+  test_enum_instanceField() async {
     await assertErrorsInCode(
       r'''
 enum A {
@@ -217,7 +614,7 @@ augment enum A {;
     );
   }
 
-  test_enum_getter() async {
+  test_enum_instanceGetter() async {
     await assertErrorsInCode(
       r'''
 enum A {
@@ -233,7 +630,7 @@ augment enum A {;
     );
   }
 
-  test_enum_method() async {
+  test_enum_instanceMethod() async {
     await assertErrorsInCode(
       r'''
 enum A {
@@ -249,7 +646,7 @@ augment enum A {;
     );
   }
 
-  test_enum_setter() async {
+  test_enum_instanceSetter() async {
     await assertErrorsInCode(
       r'''
 enum A {
@@ -274,7 +671,7 @@ augment extension A {}
     );
   }
 
-  test_extension_getter() async {
+  test_extension_instanceGetter() async {
     await assertErrorsInCode(
       r'''
 extension A on int {}
@@ -287,7 +684,7 @@ augment extension A {
     );
   }
 
-  test_extension_method() async {
+  test_extension_instanceMethod() async {
     await assertErrorsInCode(
       r'''
 extension A on int {}
@@ -300,7 +697,7 @@ augment extension A {
     );
   }
 
-  test_extension_setter() async {
+  test_extension_instanceSetter() async {
     await assertErrorsInCode(
       r'''
 extension A on int {}
@@ -335,7 +732,7 @@ augment extension type A(int it) {
     );
   }
 
-  test_extensionType_getter() async {
+  test_extensionType_instanceGetter() async {
     await assertErrorsInCode(
       r'''
 extension type A(int it) {}
@@ -348,7 +745,7 @@ augment extension type A(int it) {
     );
   }
 
-  test_extensionType_method() async {
+  test_extensionType_instanceMethod() async {
     await assertErrorsInCode(
       r'''
 extension type A(int it) {}
@@ -361,7 +758,7 @@ augment extension type A(int it) {
     );
   }
 
-  test_extensionType_setter() async {
+  test_extensionType_instanceSetter() async {
     await assertErrorsInCode(
       r'''
 extension type A(int it) {}
@@ -383,7 +780,7 @@ augment mixin A {}
     );
   }
 
-  test_mixin_field() async {
+  test_mixin_instanceField() async {
     await assertErrorsInCode(
       r'''
 mixin A {}
@@ -396,7 +793,7 @@ augment mixin A {
     );
   }
 
-  test_mixin_getter() async {
+  test_mixin_instanceGetter() async {
     await assertErrorsInCode(
       r'''
 mixin A {}
@@ -409,7 +806,7 @@ augment mixin A {
     );
   }
 
-  test_mixin_method() async {
+  test_mixin_instanceMethod() async {
     await assertErrorsInCode(
       r'''
 mixin A {}
@@ -422,7 +819,7 @@ augment mixin A {
     );
   }
 
-  test_mixin_method_valid() async {
+  test_mixin_instanceMethod_augments_instanceMethod() async {
     await assertNoErrorsInCode(r'''
 mixin A {
   void foo() {}
@@ -434,7 +831,7 @@ augment mixin A {
 ''');
   }
 
-  test_mixin_setter() async {
+  test_mixin_instanceSetter() async {
     await assertErrorsInCode(
       r'''
 mixin A {}
@@ -456,7 +853,7 @@ augment void foo() {}
     );
   }
 
-  test_topLevel_function_valid() async {
+  test_topLevel_function_augments_function() async {
     await assertNoErrorsInCode(r'''
 void foo() {}
 
@@ -511,11 +908,44 @@ augment int foo = 0;
     );
   }
 
-  test_topLevel_variable_single_valid() async {
+  test_topLevel_variable_single_augments_variable() async {
     await assertNoErrorsInCode(r'''
 int foo = 0;
 
 augment int foo = 1;
 ''');
   }
+
+  Future<void> _assertClassMemberAugmentationWithoutDeclaration({
+    required String declaration,
+    required String augmentation,
+    bool conflictAtAugmentation = true,
+    bool expectConflict = true,
+  }) async {
+    var code =
+        '''
+class A {
+  $declaration
+}
+augment class A {
+  augment $augmentation
+}
+''';
+
+    await assertErrorsInCode(code, [
+      if (expectConflict)
+        error(
+          diag.conflictingStaticAndInstance,
+          conflictAtAugmentation
+              ? code.lastIndexOf('foo')
+              : code.indexOf('foo'),
+          3,
+        ),
+      error(
+        diag.augmentationWithoutDeclaration,
+        code.indexOf('augment $augmentation'),
+        7,
+      ),
+    ]);
+  }
 }
diff --git a/pkg/analyzer/test/src/summary/element_text.dart b/pkg/analyzer/test/src/summary/element_text.dart
index 9a96b805a0f..07946d51790 100644
--- a/pkg/analyzer/test/src/summary/element_text.dart
+++ b/pkg/analyzer/test/src/summary/element_text.dart
@@ -363,6 +363,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
@@ -583,6 +587,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
@@ -891,6 +899,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
@@ -998,6 +1010,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       // _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
@@ -1259,6 +1275,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       // _writeElementReference(e.enclosingElement, label: 'enclosingElement');
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
@@ -1441,6 +1461,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
@@ -1532,6 +1556,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
@@ -1625,6 +1653,10 @@ class _Element2Writer extends _AbstractElementWriter {
     _sink.withIndent(() {
       _writeReference(e);
       _writeFragmentReference('firstFragment', e.firstFragment);
+      _writeFragmentReference(
+        'previousFragmentOfDifferentKind',
+        e.previousFragmentOfDifferentKind,
+      );
       _writeDocumentation(e.documentationComment);
       _writeMetadata(e.metadata);
       _writeSinceSdkVersion(e);
diff --git a/pkg/analyzer/test/src/summary/elements/class_test.dart b/pkg/analyzer/test/src/summary/elements/class_test.dart
index ec9d8209e74..12f741a332a 100644
--- a/pkg/analyzer/test/src/summary/elements/class_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/class_test.dart
@@ -27799,6 +27799,7 @@ library
         hasInitializer isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@field::foo
           firstFragment: #F5
+          previousFragmentOfDifferentKind: #F4
           type: int
           getter: <testLibrary>::@class::A::@getter::foo
           setter: <testLibrary>::@class::A::@setter::foo
@@ -28444,6 +28445,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@getter::foo
           firstFragment: #F6
+          previousFragmentOfDifferentKind: #F4
           returnType: int
           variable: <testLibrary>::@class::A::@field::foo
       methods
@@ -28513,6 +28515,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@getter::foo
           firstFragment: #F7
+          previousFragmentOfDifferentKind: #F5
           returnType: int
           variable: <testLibrary>::@class::A::@field::foo
       setters
@@ -29494,6 +29497,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@method::foo
           firstFragment: #F8
+          previousFragmentOfDifferentKind: #F3
           returnType: void
 ''');
   }
@@ -29559,6 +29563,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@method::foo
           firstFragment: #F6
+          previousFragmentOfDifferentKind: #F5
           returnType: void
 ''');
   }
@@ -29631,6 +29636,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@method::foo
           firstFragment: #F7
+          previousFragmentOfDifferentKind: #F5
           returnType: void
 ''');
   }
@@ -30419,6 +30425,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@setter::foo
           firstFragment: #F6
+          previousFragmentOfDifferentKind: #F5
           formalParameters
             #E0 requiredPositional _
               firstFragment: #F7
@@ -30486,6 +30493,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@class::A::@setter::foo
           firstFragment: #F6
+          previousFragmentOfDifferentKind: #F4
           formalParameters
             #E0 requiredPositional _
               firstFragment: #F7
@@ -30859,6 +30867,7 @@ library
     isSimplyBounded mixin A
       reference: <testLibrary>::@mixin::A
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       superclassConstraints
         Object
 ''');
@@ -30908,6 +30917,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A::@def::1
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F5
       constructors
         isOriginImplicitDefault new
           reference: <testLibrary>::@class::A::@def::1::@constructor::new
@@ -30916,11 +30926,4228 @@ library
     isSimplyBounded mixin A
       reference: <testLibrary>::@mixin::A
       firstFragment: #F5
+      previousFragmentOfDifferentKind: #F1
       superclassConstraints
         Object
 ''');
   }
 
+  test_class_constructor_augments_instanceField() async {
+    var library = await buildLibrary(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:16) (offset:16)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F4 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F5 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:41) (firstTokenOffset:27) (offset:41)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F7 isAugmentation isOriginDeclaration foo (nameOffset:57) (firstTokenOffset:47) (offset:57)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 55
+              periodOffset: 56
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F7
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F4
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_constructor_augments_instanceGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F4 isCompleteDeclaration isOriginDeclaration foo (nameOffset:20) (firstTokenOffset:12) (offset:20)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F5 isAugmentation isOriginDeclaration foo (nameOffset:62) (firstTokenOffset:52) (offset:62)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 60
+              periodOffset: 61
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F5
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F4
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_constructor_augments_instanceMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          methods
+            #F3 isCompleteDeclaration isOriginDeclaration foo (nameOffset:17) (firstTokenOffset:12) (offset:17)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:42) (firstTokenOffset:28) (offset:42)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F4 isAugmentation isOriginDeclaration foo (nameOffset:58) (firstTokenOffset:48) (offset:58)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 56
+              periodOffset: 57
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F4
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F3
+          returnType: void
+''');
+  }
+
+  test_class_constructor_augments_instanceSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F4 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:12) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F5 requiredPositional isOriginDeclaration _ (nameOffset:24) (firstTokenOffset:20) (offset:24)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F6 isAugmentation isOriginDeclaration foo (nameOffset:62) (firstTokenOffset:52) (offset:62)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 60
+              periodOffset: 61
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F6
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F4
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F5
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_constructor_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F4 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F7 isAugmentation isOriginDeclaration foo (nameOffset:64) (firstTokenOffset:54) (offset:64)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 62
+              periodOffset: 63
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F7
+          previousFragmentOfDifferentKind: #F3
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F4
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_constructor_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F5 isAugmentation isOriginDeclaration foo (nameOffset:69) (firstTokenOffset:59) (offset:69)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 67
+              periodOffset: 68
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F5
+          previousFragmentOfDifferentKind: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F4
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_constructor_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          methods
+            #F3 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F4 isAugmentation isOriginDeclaration foo (nameOffset:65) (firstTokenOffset:55) (offset:65)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 63
+              periodOffset: 64
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F4
+          previousFragmentOfDifferentKind: #F3
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F3
+          returnType: void
+''');
+  }
+
+  test_class_constructor_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment A.foo();
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F4 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F5 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          constructors
+            #F6 isAugmentation isOriginDeclaration foo (nameOffset:69) (firstTokenOffset:59) (offset:69)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 67
+              periodOffset: 68
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F6
+          previousFragmentOfDifferentKind: #F4
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F4
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F5
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_instanceField_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 hasInitializer isAugmentation isOriginDeclaration foo (nameOffset:55) (firstTokenOffset:55) (offset:55)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F5 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:55)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:55)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:55)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F4
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_instanceField_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F8 hasInitializer isAugmentation isOriginDeclaration foo (nameOffset:66) (firstTokenOffset:66) (offset:66)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F9 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:66)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+          setters
+            #F10 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:66)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F11 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:66)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::value
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F8
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F9
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F10
+          formalParameters
+            #E1 requiredPositional value
+              firstFragment: #F11
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_instanceField_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F6 hasInitializer isAugmentation isOriginDeclaration foo (nameOffset:71) (firstTokenOffset:71) (offset:71)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F7 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+          setters
+            #F8 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F9 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F6
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F7
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F8
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F9
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_instanceField_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 hasInitializer isAugmentation isOriginDeclaration foo (nameOffset:67) (firstTokenOffset:67) (offset:67)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F6 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:67)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F7 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:67)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F8 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:67)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F7
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F8
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_instanceField_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F7 hasInitializer isAugmentation isOriginDeclaration foo (nameOffset:71) (firstTokenOffset:71) (offset:71)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F8 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F9 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F10 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::value
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F7
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F8
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F9
+          formalParameters
+            #E1 requiredPositional value
+              firstFragment: #F10
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_instanceGetter_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:37)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F5 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:59) (firstTokenOffset:43) (offset:59)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F4
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_instanceGetter_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F8 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:48)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F9 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:70) (firstTokenOffset:54) (offset:70)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+          setter: <testLibrary>::@class::A::@setter::foo
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F8
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F9
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+''');
+  }
+
+  test_class_instanceGetter_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F6 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:53)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F7 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:75) (firstTokenOffset:59) (offset:75)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F6
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F7
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_instanceGetter_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:49)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:71) (firstTokenOffset:55) (offset:71)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_instanceGetter_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F7 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:53)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F8 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:75) (firstTokenOffset:59) (offset:75)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F7
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F8
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+''');
+  }
+
+  test_class_instanceMethod_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F4 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:56) (firstTokenOffset:43) (offset:56)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_instanceMethod_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F8 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:67) (firstTokenOffset:54) (offset:67)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F8
+          returnType: void
+''');
+  }
+
+  test_class_instanceMethod_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:72) (firstTokenOffset:59) (offset:72)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F6
+          returnType: void
+''');
+  }
+
+  test_class_instanceMethod_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo::@def::0
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F5 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:68) (firstTokenOffset:55) (offset:68)
+              element: <testLibrary>::@class::A::@method::foo::@def::1
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo::@def::0
+          firstFragment: #F4
+          returnType: void
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo::@def::1
+          firstFragment: #F5
+          returnType: void
+''');
+  }
+
+  test_class_instanceMethod_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F7 isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:72) (firstTokenOffset:59) (offset:72)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F7
+          returnType: void
+''');
+  }
+
+  test_class_instanceSetter_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:37)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F5 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:55) (firstTokenOffset:43) (offset:55)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:63) (firstTokenOffset:59) (offset:63)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F4
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_instanceSetter_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F8 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:48)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          setters
+            #F9 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:66) (firstTokenOffset:54) (offset:66)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F10 requiredPositional isOriginDeclaration _ (nameOffset:74) (firstTokenOffset:70) (offset:74)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F8
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F9
+          formalParameters
+            #E1 requiredPositional _
+              firstFragment: #F10
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_instanceSetter_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F6 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:53)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          setters
+            #F7 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:71) (firstTokenOffset:59) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F8 requiredPositional isOriginDeclaration _ (nameOffset:79) (firstTokenOffset:75) (offset:79)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F6
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F7
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F8
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_instanceSetter_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:49)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F6 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:67) (firstTokenOffset:55) (offset:67)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional isOriginDeclaration _ (nameOffset:75) (firstTokenOffset:71) (offset:75)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_instanceSetter_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F7 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:53)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          setters
+            #F8 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration foo (nameOffset:71) (firstTokenOffset:59) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F9 requiredPositional isOriginDeclaration _ (nameOffset:79) (firstTokenOffset:75) (offset:79)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F7
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F8
+          formalParameters
+            #E1 requiredPositional _
+              firstFragment: #F9
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticField_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:62) (firstTokenOffset:62) (offset:62)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:62)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:62)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:62)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F4
+          previousFragmentOfDifferentKind: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticField_augments_instanceField() async {
+    var library = await buildLibrary(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:16) (offset:16)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+          setters
+            #F6 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:41) (firstTokenOffset:27) (offset:41)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F8 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:66) (firstTokenOffset:66) (offset:66)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F9 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:66)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+          setters
+            #F10 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:66)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F11 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:66)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::value
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F8
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F9
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F10
+          formalParameters
+            #E1 requiredPositional value
+              firstFragment: #F11
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticField_augments_instanceGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration foo (nameOffset:20) (firstTokenOffset:12) (offset:20)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F6 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:71) (firstTokenOffset:71) (offset:71)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F7 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+          setters
+            #F8 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F9 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F6
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F7
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F8
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F9
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticField_augments_instanceMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration foo (nameOffset:17) (firstTokenOffset:12) (offset:17)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:42) (firstTokenOffset:28) (offset:42)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:67) (firstTokenOffset:67) (offset:67)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:67)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F7 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:67)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F8 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:67)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F7
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F8
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_staticField_augments_instanceSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:12) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:24) (firstTokenOffset:20) (offset:24)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F7 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:71) (firstTokenOffset:71) (offset:71)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F8 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F9 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F10 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:71)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::value
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F7
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F8
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F9
+          formalParameters
+            #E1 requiredPositional value
+              firstFragment: #F10
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticField_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+              nextFragment: #F4
+          constructors
+            #F5 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F6 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:78) (firstTokenOffset:78) (offset:78)
+              element: <testLibrary>::@class::A::@field::foo
+              previousFragment: #F3
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F5
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticField_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:74) (firstTokenOffset:74) (offset:74)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:74)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F7 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:74)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F8 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:74)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          previousFragmentOfDifferentKind: #F4
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F7
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F8
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_staticField_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment static int foo = 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+              nextFragment: #F4
+          constructors
+            #F5 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F6 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 hasInitializer isAugmentation isOriginDeclaration isStatic foo (nameOffset:78) (firstTokenOffset:78) (offset:78)
+              element: <testLibrary>::@class::A::@field::foo
+              previousFragment: #F3
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F5
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticGetter_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:37)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F5 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:66) (firstTokenOffset:43) (offset:66)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F4
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          previousFragmentOfDifferentKind: #F3
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticGetter_augments_instanceField() async {
+    var library = await buildLibrary(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:16) (offset:16)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+          setters
+            #F6 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:41) (firstTokenOffset:27) (offset:41)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F8 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:41)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F9 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:70) (firstTokenOffset:47) (offset:70)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+          setter: <testLibrary>::@class::A::@setter::foo
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F8
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F9
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+''');
+  }
+
+  test_class_staticGetter_augments_instanceGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration foo (nameOffset:20) (firstTokenOffset:12) (offset:20)
+              element: <testLibrary>::@class::A::@getter::foo::@def::0
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F6 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:46)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F7 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:75) (firstTokenOffset:52) (offset:75)
+              element: <testLibrary>::@class::A::@getter::foo::@def::1
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::0
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F6
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::0
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo::@def::1
+          firstFragment: #F7
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticGetter_augments_instanceMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration foo (nameOffset:17) (firstTokenOffset:12) (offset:17)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:42) (firstTokenOffset:28) (offset:42)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:42)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:71) (firstTokenOffset:48) (offset:71)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_staticGetter_augments_instanceSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:12) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:24) (firstTokenOffset:20) (offset:24)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F7 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:46)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          getters
+            #F8 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:75) (firstTokenOffset:52) (offset:75)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F7
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F8
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+''');
+  }
+
+  test_class_staticGetter_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo
+              nextFragment: #F6
+          setters
+            #F7 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F8 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          getters
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:77) (firstTokenOffset:54) (offset:77)
+              element: <testLibrary>::@class::A::@getter::foo
+              previousFragment: #F5
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F7
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F8
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticGetter_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment static int get foo => 0;
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:49)
+              element: <testLibrary>::@class::A::@field::foo
+          getters
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:78) (firstTokenOffset:55) (offset:78)
+              element: <testLibrary>::@class::A::@getter::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F6
+          previousFragmentOfDifferentKind: #F4
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F4 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:63) (firstTokenOffset:43) (offset:63)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          previousFragmentOfDifferentKind: #F3
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_instanceField() async {
+    var library = await buildLibrary(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:16) (offset:16)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:41) (firstTokenOffset:27) (offset:41)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F8 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:67) (firstTokenOffset:47) (offset:67)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F8
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_instanceGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration foo (nameOffset:20) (firstTokenOffset:12) (offset:20)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:72) (firstTokenOffset:52) (offset:72)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F6
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_instanceMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration foo (nameOffset:17) (firstTokenOffset:12) (offset:17)
+              element: <testLibrary>::@class::A::@method::foo::@def::0
+        #F2 isAugmentation class A (nameOffset:42) (firstTokenOffset:28) (offset:42)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F5 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:68) (firstTokenOffset:48) (offset:68)
+              element: <testLibrary>::@class::A::@method::foo::@def::1
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo::@def::0
+          firstFragment: #F4
+          returnType: void
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo::@def::1
+          firstFragment: #F5
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_instanceSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:12) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:24) (firstTokenOffset:20) (offset:24)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F7 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:72) (firstTokenOffset:52) (offset:72)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F7
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F8 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:74) (firstTokenOffset:54) (offset:74)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F8
+          previousFragmentOfDifferentKind: #F3
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_staticGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int get foo => 0;
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:27) (firstTokenOffset:12) (offset:27)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F6 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:79) (firstTokenOffset:59) (offset:79)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F6
+          previousFragmentOfDifferentKind: #F5
+          returnType: void
+''');
+  }
+
+  test_class_staticMethod_augments_staticSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  static set foo(int _) {}
+}
+augment class A {
+  augment static void foo() {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:12) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:31) (firstTokenOffset:27) (offset:31)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:53) (firstTokenOffset:39) (offset:53)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          methods
+            #F7 isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:79) (firstTokenOffset:59) (offset:79)
+              element: <testLibrary>::@class::A::@method::foo
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F7
+          previousFragmentOfDifferentKind: #F5
+          returnType: void
+''');
+  }
+
+  test_class_staticSetter_augments_constructor() async {
+    var library = await buildLibrary(r'''
+class A {
+  A.foo();
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginDeclaration foo (nameOffset:14) (firstTokenOffset:12) (offset:14)
+              element: <testLibrary>::@class::A::@constructor::foo
+              typeName: A
+              typeNameOffset: 12
+              periodOffset: 13
+        #F2 isAugmentation class A (nameOffset:37) (firstTokenOffset:23) (offset:37)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F4 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:37)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F5 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:62) (firstTokenOffset:43) (offset:62)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:70) (firstTokenOffset:66) (offset:70)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F4
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@constructor::foo
+          firstFragment: #F3
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          previousFragmentOfDifferentKind: #F3
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticSetter_augments_instanceField() async {
+    var library = await buildLibrary(r'''
+class A {
+  int foo = 0;
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:16) (offset:16)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:16)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::value
+        #F2 isAugmentation class A (nameOffset:41) (firstTokenOffset:27) (offset:41)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F8 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:41)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          setters
+            #F9 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:66) (firstTokenOffset:47) (offset:66)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F10 requiredPositional isOriginDeclaration _ (nameOffset:74) (firstTokenOffset:70) (offset:74)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::_
+  classes
+    hasNonFinalField isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F8
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+      setters
+        isOriginVariable foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F9
+          formalParameters
+            #E1 requiredPositional _
+              firstFragment: #F10
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticSetter_augments_instanceGetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  int get foo => 0;
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginDeclaration foo (nameOffset:20) (firstTokenOffset:12) (offset:20)
+              element: <testLibrary>::@class::A::@getter::foo
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F6 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:46)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          setters
+            #F7 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:71) (firstTokenOffset:52) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F8 requiredPositional isOriginDeclaration _ (nameOffset:79) (firstTokenOffset:75) (offset:79)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F6
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F7
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F8
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticSetter_augments_instanceMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  void foo() {}
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration foo (nameOffset:17) (firstTokenOffset:12) (offset:17)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:42) (firstTokenOffset:28) (offset:42)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:42)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F6 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:67) (firstTokenOffset:48) (offset:67)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional isOriginDeclaration _ (nameOffset:75) (firstTokenOffset:71) (offset:75)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
+  test_class_staticSetter_augments_instanceSetter() async {
+    var library = await buildLibrary(r'''
+class A {
+  set foo(int _) {}
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 isOriginGetterSetter foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@field::foo::@def::0
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          setters
+            #F5 hasImplicitReturnType isCompleteDeclaration isOriginDeclaration foo (nameOffset:16) (firstTokenOffset:12) (offset:16)
+              element: <testLibrary>::@class::A::@setter::foo::@def::0
+              formalParameters
+                #F6 requiredPositional isOriginDeclaration _ (nameOffset:24) (firstTokenOffset:20) (offset:24)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::0::@formalParameter::_
+        #F2 isAugmentation class A (nameOffset:46) (firstTokenOffset:32) (offset:46)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F7 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:46)
+              element: <testLibrary>::@class::A::@field::foo::@def::1
+          setters
+            #F8 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:71) (firstTokenOffset:52) (offset:71)
+              element: <testLibrary>::@class::A::@setter::foo::@def::1
+              formalParameters
+                #F9 requiredPositional isOriginDeclaration _ (nameOffset:79) (firstTokenOffset:75) (offset:79)
+                  element: <testLibrary>::@class::A::@setter::foo::@def::1::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::0
+          firstFragment: #F3
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::0
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo::@def::1
+          firstFragment: #F7
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo::@def::1
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      setters
+        isOriginDeclaration foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::0
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F6
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::0
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo::@def::1
+          firstFragment: #F8
+          formalParameters
+            #E1 requiredPositional _
+              firstFragment: #F9
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo::@def::1
+''');
+  }
+
+  test_class_staticSetter_augments_staticField() async {
+    var library = await buildLibrary(r'''
+class A {
+  static int foo = 0;
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          fields
+            #F3 hasInitializer isOriginDeclaration isStatic foo (nameOffset:23) (firstTokenOffset:23) (offset:23)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F4 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F5 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F6 isCompleteDeclaration isOriginVariable isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+              nextFragment: #F8
+        #F2 isAugmentation class A (nameOffset:48) (firstTokenOffset:34) (offset:48)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          setters
+            #F8 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:73) (firstTokenOffset:54) (offset:73)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F9 requiredPositional isOriginDeclaration _ (nameOffset:81) (firstTokenOffset:77) (offset:81)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+              previousFragment: #F6
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        hasInitializer isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F3
+          type: int
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F4
+      getters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F5
+          returnType: int
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        isOriginVariable isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+''');
+  }
+
+  test_class_staticSetter_augments_staticMethod() async {
+    var library = await buildLibrary(r'''
+class A {
+  static void foo() {}
+}
+augment class A {
+  augment static set foo(int _) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:6) (firstTokenOffset:0) (offset:6)
+          element: <testLibrary>::@class::A
+          nextFragment: #F2
+          constructors
+            #F3 isOriginImplicitDefault new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:6)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          methods
+            #F4 isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:24) (firstTokenOffset:12) (offset:24)
+              element: <testLibrary>::@class::A::@method::foo
+        #F2 isAugmentation class A (nameOffset:49) (firstTokenOffset:35) (offset:49)
+          element: <testLibrary>::@class::A
+          previousFragment: #F1
+          fields
+            #F5 isOriginGetterSetter isStatic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:49)
+              element: <testLibrary>::@class::A::@field::foo
+          setters
+            #F6 hasImplicitReturnType isAugmentation isCompleteDeclaration isOriginDeclaration isStatic foo (nameOffset:74) (firstTokenOffset:55) (offset:74)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F7 requiredPositional isOriginDeclaration _ (nameOffset:82) (firstTokenOffset:78) (offset:82)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::_
+  classes
+    isSimplyBounded class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        isOriginGetterSetter isStatic foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F5
+          type: int
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        isOriginImplicitDefault new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      setters
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F6
+          previousFragmentOfDifferentKind: #F4
+          formalParameters
+            #E0 requiredPositional _
+              firstFragment: #F7
+              type: int
+          returnType: void
+          variable: <testLibrary>::@class::A::@field::foo
+      methods
+        isOriginDeclaration isStatic foo
+          reference: <testLibrary>::@class::A::@method::foo
+          firstFragment: #F4
+          returnType: void
+''');
+  }
+
   test_constructor_formalParameters_optionalPositional_11() async {
     var library = await buildLibrary(r'''
 class A {
diff --git a/pkg/analyzer/test/src/summary/elements/enum_test.dart b/pkg/analyzer/test/src/summary/elements/enum_test.dart
index 5a6ec20f45a..3d16044ebd2 100644
--- a/pkg/analyzer/test/src/summary/elements/enum_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/enum_test.dart
@@ -13728,6 +13728,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@enum::A::@setter::foo
           firstFragment: #F12
+          previousFragmentOfDifferentKind: #F5
           formalParameters
             #E0 requiredPositional _
               firstFragment: #F13
@@ -17969,6 +17970,7 @@ library
         isOriginDeclaration foo
           reference: <testLibrary>::@enum::A::@setter::foo
           firstFragment: #F10
+          previousFragmentOfDifferentKind: #F5
           formalParameters
             #E0 requiredPositional _
               firstFragment: #F11
@@ -18324,6 +18326,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F3
   enums
     isSimplyBounded enum A
       reference: <testLibrary>::@enum::A
@@ -18432,6 +18435,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F2
   enums
     isSimplyBounded enum A
       reference: <testLibrary>::@enum::A::@def::0
@@ -18468,6 +18472,7 @@ library
     isSimplyBounded enum A
       reference: <testLibrary>::@enum::A::@def::1
       firstFragment: #F7
+      previousFragmentOfDifferentKind: #F1
       supertype: Enum
       fields
         isConst isOriginEnumValues isStatic values
diff --git a/pkg/analyzer/test/src/summary/elements/extension_test.dart b/pkg/analyzer/test/src/summary/elements/extension_test.dart
index d0a3847187d..c70704750ec 100644
--- a/pkg/analyzer/test/src/summary/elements/extension_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/extension_test.dart
@@ -2942,6 +2942,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F3
   extensions
     extension A
       reference: <testLibrary>::@extension::A
@@ -2979,6 +2980,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F2
   extensions
     extension A
       reference: <testLibrary>::@extension::A::@def::0
@@ -2988,6 +2990,7 @@ library
     extension A
       reference: <testLibrary>::@extension::A::@def::1
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       extendedType: InvalidType
       onDeclaration: <null>
 ''');
diff --git a/pkg/analyzer/test/src/summary/elements/extension_type_test.dart b/pkg/analyzer/test/src/summary/elements/extension_type_test.dart
index e2801914167..5227187c147 100644
--- a/pkg/analyzer/test/src/summary/elements/extension_type_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/extension_type_test.dart
@@ -12019,6 +12019,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F3
   extensionTypes
     isSimplyBounded extension type A
       reference: <testLibrary>::@extensionType::A
@@ -12082,6 +12083,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F2
   extensionTypes
     isSimplyBounded extension type A
       reference: <testLibrary>::@extensionType::A::@def::0
@@ -12105,6 +12107,7 @@ library
     isSimplyBounded extension type A
       reference: <testLibrary>::@extensionType::A::@def::1
       firstFragment: #F5
+      previousFragmentOfDifferentKind: #F1
       representation: <testLibrary>::@extensionType::A::@def::1::@field::it
       primaryConstructor: <testLibrary>::@extensionType::A::@def::1::@constructor::new
       typeErasure: int
diff --git a/pkg/analyzer/test/src/summary/elements/mixin_test.dart b/pkg/analyzer/test/src/summary/elements/mixin_test.dart
index 150dbb566db..9fbc86638b8 100644
--- a/pkg/analyzer/test/src/summary/elements/mixin_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/mixin_test.dart
@@ -4499,6 +4499,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F3
   mixins
     isSimplyBounded mixin A
       reference: <testLibrary>::@mixin::A
@@ -4538,6 +4539,7 @@ library
     isSimplyBounded class A
       reference: <testLibrary>::@class::A
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F3
       constructors
         isOriginImplicitDefault new
           reference: <testLibrary>::@class::A::@constructor::new
@@ -4551,6 +4553,7 @@ library
     isSimplyBounded mixin A
       reference: <testLibrary>::@mixin::A::@def::1
       firstFragment: #F4
+      previousFragmentOfDifferentKind: #F1
       superclassConstraints
         Object
 ''');
diff --git a/pkg/analyzer/test/src/summary/elements/top_level_function_test.dart b/pkg/analyzer/test/src/summary/elements/top_level_function_test.dart
index 1c2ba2f3af5..3bfe67b69ba 100644
--- a/pkg/analyzer/test/src/summary/elements/top_level_function_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/top_level_function_test.dart
@@ -1280,6 +1280,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@function::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F2
       returnType: void
 ''');
   }
@@ -1355,6 +1356,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@function::foo
       firstFragment: #F4
+      previousFragmentOfDifferentKind: #F2
       returnType: void
 ''');
   }
@@ -1413,6 +1415,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@function::foo
       firstFragment: #F5
+      previousFragmentOfDifferentKind: #F1
       returnType: void
 ''');
   }
@@ -1596,6 +1599,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@function::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       returnType: void
 ''');
   }
diff --git a/pkg/analyzer/test/src/summary/elements/top_level_variable_test.dart b/pkg/analyzer/test/src/summary/elements/top_level_variable_test.dart
index 7840ede27f7..3a1e2a1f4ed 100644
--- a/pkg/analyzer/test/src/summary/elements/top_level_variable_test.dart
+++ b/pkg/analyzer/test/src/summary/elements/top_level_variable_test.dart
@@ -2908,6 +2908,7 @@ library
     isOriginDeclaration isStatic A
       reference: <testLibrary>::@getter::A
       firstFragment: #F4
+      previousFragmentOfDifferentKind: #F1
       returnType: int
       variable: <testLibrary>::@topLevelVariable::A
   exportedReferences
@@ -2949,6 +2950,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@getter::foo
       firstFragment: #F2
+      previousFragmentOfDifferentKind: #F3
       returnType: int
       variable: <testLibrary>::@topLevelVariable::foo
   functions
@@ -3319,6 +3321,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@getter::foo
       firstFragment: #F2
+      previousFragmentOfDifferentKind: #F3
       returnType: int
       variable: <testLibrary>::@topLevelVariable::foo
   setters
@@ -3654,6 +3657,7 @@ library
     isOriginDeclaration isStatic A
       reference: <testLibrary>::@setter::A
       firstFragment: #F4
+      previousFragmentOfDifferentKind: #F1
       formalParameters
         #E0 requiredPositional _
           firstFragment: #F5
@@ -3704,6 +3708,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@setter::foo
       firstFragment: #F2
+      previousFragmentOfDifferentKind: #F4
       formalParameters
         #E0 requiredPositional _
           firstFragment: #F3
@@ -3766,6 +3771,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@setter::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F2
       formalParameters
         #E0 requiredPositional _
           firstFragment: #F4
@@ -3823,6 +3829,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@setter::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F2
       formalParameters
         #E0 requiredPositional _
           firstFragment: #F4
@@ -4287,6 +4294,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@setter::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       metadata
         Annotation
           atSign: @ @15
@@ -4358,6 +4366,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@setter::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       formalParameters
         #E0 requiredPositional _
           firstFragment: #F4
@@ -4473,6 +4482,7 @@ library
     isOriginDeclaration isStatic foo
       reference: <testLibrary>::@setter::foo
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       formalParameters
         #E0 requiredPositional _
           firstFragment: #F4
@@ -4532,6 +4542,7 @@ library
     hasInitializer isOriginDeclaration isStatic A
       reference: <testLibrary>::@topLevelVariable::A
       firstFragment: #F3
+      previousFragmentOfDifferentKind: #F1
       type: int
       getter: <testLibrary>::@getter::A
       setter: <testLibrary>::@setter::A
@@ -4592,6 +4603,7 @@ library
     hasInitializer isOriginDeclaration isStatic foo
       reference: <testLibrary>::@topLevelVariable::foo
       firstFragment: #F1
+      previousFragmentOfDifferentKind: #F5
       type: int
       getter: <testLibrary>::@getter::foo
       setter: <testLibrary>::@setter::foo