Check for const and factory mismatch between constructors in Class, Enum, and Extension Type.

Change-Id: Ib34306676b8555a49bb15896c60f1065e69c3035
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/517622
Reviewed-by: Paul Berry <paulberry@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: fshcheglov

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -671,6 +671,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     var element = fragment.element;
 
     _checkAugmentationWithoutDeclaration(node.augmentKeyword, fragment);
+    _checkForConstructorAugmentationModifierMismatch(node, fragment);
     _checkForAugmentationFormalParameters(
       executableFragment: fragment,
       formalParameterList: node.parameters,
@@ -3128,6 +3129,32 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     }
   }
 
+  void _checkForAugmentationModifierMismatch({
+    required Token augmentKeyword,
+    required bool inAugmentation,
+    required bool inIntroductory,
+    required Token? modifierToken,
+    required String modifierName,
+  }) {
+    if (inAugmentation != inIntroductory) {
+      if (inAugmentation) {
+        if (modifierToken != null) {
+          diagnosticReporter.report(
+            diag.augmentationModifierExtra
+                .withArguments(modifier: modifierName)
+                .at(modifierToken),
+          );
+        }
+      } else {
+        diagnosticReporter.report(
+          diag.augmentationModifierMissing
+              .withArguments(modifier: modifierName)
+              .at(augmentKeyword),
+        );
+      }
+    }
+  }
+
   void _checkForAugmentationReturnTypeMismatch({
     required ExecutableFragmentImpl fragment,
     required TypeAnnotation? returnTypeNode,
@@ -3372,62 +3399,43 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       return;
     }
 
-    void checkModifier({
-      required bool inAugmentation,
-      required bool inIntroductory,
-      required Token? modifierToken,
-      required String modifierName,
-    }) {
-      if (inAugmentation != inIntroductory) {
-        if (inAugmentation) {
-          if (modifierToken != null) {
-            diagnosticReporter.report(
-              diag.augmentationModifierExtra
-                  .withArguments(modifier: modifierName)
-                  .at(modifierToken),
-            );
-          }
-        } else {
-          diagnosticReporter.report(
-            diag.augmentationModifierMissing
-                .withArguments(modifier: modifierName)
-                .at(augmentKeyword),
-          );
-        }
-      }
-    }
-
-    checkModifier(
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
       inAugmentation: declaredFragment.isAbstract,
       inIntroductory: firstFragment.isAbstract,
       modifierToken: node.abstractKeyword,
       modifierName: 'abstract',
     );
-    checkModifier(
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
       inAugmentation: declaredFragment.isBase,
       inIntroductory: firstFragment.isBase,
       modifierToken: node.baseKeyword,
       modifierName: 'base',
     );
-    checkModifier(
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
       inAugmentation: declaredFragment.isFinal,
       inIntroductory: firstFragment.isFinal,
       modifierToken: node.finalKeyword,
       modifierName: 'final',
     );
-    checkModifier(
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
       inAugmentation: declaredFragment.isInterface,
       inIntroductory: firstFragment.isInterface,
       modifierToken: node.interfaceKeyword,
       modifierName: 'interface',
     );
-    checkModifier(
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
       inAugmentation: declaredFragment.isSealed,
       inIntroductory: firstFragment.isSealed,
       modifierToken: node.sealedKeyword,
       modifierName: 'sealed',
     );
-    checkModifier(
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
       inAugmentation: declaredFragment.isMixinClass,
       inIntroductory: firstFragment.isMixinClass,
       modifierToken: node.mixinKeyword,
@@ -4200,6 +4208,36 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     }
   }
 
+  void _checkForConstructorAugmentationModifierMismatch(
+    ConstructorDeclarationImpl node,
+    ConstructorFragmentImpl declaredFragment,
+  ) {
+    var augmentKeyword = node.augmentKeyword;
+    if (augmentKeyword == null) {
+      return;
+    }
+
+    var firstFragment = declaredFragment.element.firstFragment;
+    if (identical(declaredFragment, firstFragment)) {
+      return;
+    }
+
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
+      inAugmentation: declaredFragment.isConst,
+      inIntroductory: firstFragment.isConst,
+      modifierToken: node.constKeyword,
+      modifierName: 'const',
+    );
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
+      inAugmentation: declaredFragment.isFactory,
+      inIntroductory: firstFragment.isFactory,
+      modifierToken: node.factoryKeyword,
+      modifierName: 'factory',
+    );
+  }
+
   bool _checkForConstVariableAugmentation({
     required Token errorToken,
     required PropertyInducingFragmentImpl fragment,
@@ -5912,23 +5950,13 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       return;
     }
 
-    if (declaredFragment.isBase != firstFragment.isBase) {
-      if (declaredFragment.isBase) {
-        if (node.baseKeyword case var baseKeyword?) {
-          diagnosticReporter.report(
-            diag.augmentationModifierExtra
-                .withArguments(modifier: 'base')
-                .at(baseKeyword),
-          );
-        }
-      } else {
-        diagnosticReporter.report(
-          diag.augmentationModifierMissing
-              .withArguments(modifier: 'base')
-              .at(augmentKeyword),
-        );
-      }
-    }
+    _checkForAugmentationModifierMismatch(
+      augmentKeyword: augmentKeyword,
+      inAugmentation: declaredFragment.isBase,
+      inIntroductory: firstFragment.isBase,
+      modifierToken: node.baseKeyword,
+      modifierName: 'base',
+    );
   }
 
   /// Verify that mixin classes must have 'Object' as their superclass and that

pkg/analyzer/test/src/diagnostics/augmentation_modifier_extra_test.dart

@@ -41,6 +41,28 @@ augment abstract base class A {}
 ''');
   }
 
+  test_class_constructor_secondary_nothing_const() async {
+    await resolveTestCodeWithDiagnostics(r'''
+class A {
+  A();
+  augment const A();
+//        ^^^^^
+// [diag.augmentationModifierExtra] The augmentation has the 'const' modifier that the declaration doesn't have.
+}
+''');
+  }
+
+  test_class_constructor_secondary_nothing_factory() async {
+    await resolveTestCodeWithDiagnostics(r'''
+class A {
+  A();
+  augment factory A();
+//        ^^^^^^^
+// [diag.augmentationModifierExtra] The augmentation has the 'factory' modifier that the declaration doesn't have.
+}
+''');
+  }
+
   test_class_nothing_abstract() async {
     await resolveTestCodeWithDiagnostics(r'''
 class A {}
@@ -116,6 +138,35 @@ augment sealed class A {}
 ''');
   }
 
+  test_enum_constructor_primary_const_factory() async {
+    await resolveTestCodeWithDiagnostics(r'''
+enum E.named() {
+  v.named();
+}
+
+augment enum E {
+  ;
+  augment factory E.named();
+//^^^^^^^
+// [diag.augmentationModifierMissing] The augmentation is missing the 'const' modifier that the declaration has.
+//        ^^^^^^^
+// [diag.augmentationModifierExtra] The augmentation has the 'factory' modifier that the declaration doesn't have.
+}
+''');
+  }
+
+  test_extensionType_constructor_primary_nothing_factory() async {
+    await resolveTestCodeWithDiagnostics(r'''
+extension type E(int it);
+
+augment extension type E {
+  augment factory E(int it);
+//        ^^^^^^^
+// [diag.augmentationModifierExtra] The augmentation has the 'factory' modifier that the declaration doesn't have.
+}
+''');
+  }
+
   test_mixin_base_base() async {
     await resolveTestCodeWithDiagnostics(r'''
 base mixin A {}

pkg/analyzer/test/src/diagnostics/augmentation_modifier_missing_test.dart

@@ -73,6 +73,29 @@ augment class A {}
 ''');
   }
 
+  test_class_constructor_secondary_const_nothing() async {
+    await resolveTestCodeWithDiagnostics(r'''
+class A {
+  const A();
+  augment A();
+//^^^^^^^
+// [diag.augmentationModifierMissing] The augmentation is missing the 'const' modifier that the declaration has.
+}
+''');
+  }
+
+  test_class_constructor_secondary_factory_nothing() async {
+    await resolveTestCodeWithDiagnostics(r'''
+class A {
+  A._();
+  factory A() = A._;
+  augment A();
+//^^^^^^^
+// [diag.augmentationModifierMissing] The augmentation is missing the 'factory' modifier that the declaration has.
+}
+''');
+  }
+
   test_class_final_nothing() async {
     await resolveTestCodeWithDiagnostics(r'''
 final class A {}
@@ -105,6 +128,35 @@ augment class A {}
 ''');
   }
 
+  test_enum_constructor_secondary_factory_nothing() async {
+    await resolveTestCodeWithDiagnostics(r'''
+enum E {
+  v;
+
+  factory E.named() => v;
+}
+
+augment enum E {
+  ;
+  augment E.named();
+//^^^^^^^
+// [diag.augmentationModifierMissing] The augmentation is missing the 'factory' modifier that the declaration has.
+}
+''');
+  }
+
+  test_extensionType_constructor_primary_const_nothing() async {
+    await resolveTestCodeWithDiagnostics(r'''
+extension type const E(int it);
+
+augment extension type E {
+  augment E(int it);
+//^^^^^^^
+// [diag.augmentationModifierMissing] The augmentation is missing the 'const' modifier that the declaration has.
+}
+''');
+  }
+
   test_mixin_base_base() async {
     await resolveTestCodeWithDiagnostics(r'''
 base mixin A {}

pkg/linter/test/rules/use_key_in_widget_constructors_test.dart

@@ -29,7 +29,7 @@ import 'package:flutter/widgets.dart';
 part 'test.dart';
 
 class W extends StatelessWidget {
-  W();
+  const W();
 
   @override
   Widget build(BuildContext context) => Container();