[analyzer/linter] Dot shorthands: Update ConstantVerifier for dot shorthand constructor invocations.

Updates the `ConstantVerifier` so we're checking the dot shorthand constructor invocation is a constant constructor call and that its arguments are constant expressions.

Tweaked the constant error handling a little bit to handle dot shorthands. It's always a little funky, but needed to prevent duplicate errors.

Added a few unit tests from the example in the bug.

Fixes: #60963
Bug: #60893
Change-Id: I77b2dff4a274241b2c98b3e6cd34c620d08435a7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/436742
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: kallentu

pkg/analyzer/lib/src/dart/constant/constant_verifier.dart

@@ -206,6 +206,24 @@ class ConstantVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+    DotShorthandConstructorInvocation node,
+  ) {
+    if (node.isConst) {
+      var constructor = node.constructorName.element;
+      if (constructor is ConstructorElementMixin2) {
+        _validateConstructorInvocation(
+          node,
+          constructor.asElement,
+          node.argumentList,
+        );
+      }
+    } else {
+      super.visitDotShorthandConstructorInvocation(node);
+    }
+  }
+
   @override
   visitEnumConstantDeclaration(covariant EnumConstantDeclarationImpl node) {
     super.visitEnumConstantDeclaration(node);
@@ -270,38 +288,9 @@ class ConstantVerifier extends RecursiveAstVisitor<void> {
         CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
       );
 
-      // We need to evaluate the constant to see if any errors occur during its
-      // evaluation.
       var constructor = node.constructorName.element?.asElement;
       if (constructor != null) {
-        var constantVisitor = ConstantVisitor(
-          _evaluationEngine,
-          _currentLibrary,
-          _diagnosticReporter,
-        );
-        var result = _evaluationEngine.evaluateAndFormatErrorsInConstructorCall(
-          _currentLibrary,
-          node,
-          constructor.returnType.typeArguments,
-          node.argumentList.arguments,
-          constructor,
-          constantVisitor,
-        );
-        switch (result) {
-          case InvalidConstant():
-            if (!result.avoidReporting) {
-              _diagnosticReporter.atOffset(
-                offset: result.offset,
-                length: result.length,
-                diagnosticCode: result.diagnosticCode,
-                arguments: result.arguments,
-                contextMessages: result.contextMessages,
-              );
-            }
-          case DartObjectImpl():
-            // Check for further errors in individual arguments.
-            node.argumentList.accept(this);
-        }
+        _validateConstructorInvocation(node, constructor, node.argumentList);
       }
     } else {
       super.visitInstanceCreationExpression(node);
@@ -923,6 +912,43 @@ class ConstantVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
+  /// Validates that the [constructor] invocation, its type arguments, and its
+  /// arguments are constant expressions.
+  void _validateConstructorInvocation(
+    AstNode node,
+    ConstructorElementMixin constructor,
+    ArgumentList argumentList,
+  ) {
+    var constantVisitor = ConstantVisitor(
+      _evaluationEngine,
+      _currentLibrary,
+      _diagnosticReporter,
+    );
+    var result = _evaluationEngine.evaluateAndFormatErrorsInConstructorCall(
+      _currentLibrary,
+      node,
+      constructor.returnType.typeArguments,
+      argumentList.arguments,
+      constructor,
+      constantVisitor,
+    );
+    switch (result) {
+      case InvalidConstant():
+        if (!result.avoidReporting) {
+          _diagnosticReporter.atOffset(
+            offset: result.offset,
+            length: result.length,
+            diagnosticCode: result.diagnosticCode,
+            arguments: result.arguments,
+            contextMessages: result.contextMessages,
+          );
+        }
+      case DartObjectImpl():
+        // Check for further errors in individual arguments.
+        argumentList.accept(this);
+    }
+  }
+
   /// Validates that the default value associated with each of the parameters in
   /// [parameters] is a constant expression.
   void _validateDefaultValues(covariant FormalParameterListImpl? parameters) {

pkg/analyzer/lib/src/dart/constant/evaluation.dart

@@ -3560,17 +3560,14 @@ class _InstanceCreationEvaluator {
     ConstructorInvocation? invocation,
   }) {
     if (!constructor.isConst) {
+      Token? keyword;
       if (node is InstanceCreationExpression) {
-        var newKeyword = node.keyword;
-        if (newKeyword != null) {
-          return InvalidConstant.forEntity(
-            entity: newKeyword,
-            diagnosticCode: CompileTimeErrorCode.CONST_WITH_NON_CONST,
-          );
-        }
+        keyword = node.keyword;
+      } else if (node is DotShorthandConstructorInvocation) {
+        keyword = node.constKeyword;
       }
       return InvalidConstant.forEntity(
-        entity: node,
+        entity: keyword ?? node,
         diagnosticCode: CompileTimeErrorCode.CONST_WITH_NON_CONST,
       );
     }

pkg/analyzer/test/src/dart/constant/evaluation_test.dart

@@ -6111,6 +6111,44 @@ bool true
     );
   }
 
+  test_dotShorthand_constantArgument_issue60963() async {
+    await assertNoErrorsInCode('''
+class A {
+  const A();
+}
+extension type const B(A a) {}
+
+const B b = .new(A());
+''');
+    var result = _topLevelVar('b');
+    assertDartObjectText(result, '''
+A
+  variable: <testLibrary>::@topLevelVariable::b
+''');
+  }
+
+  test_dotShorthand_nonConstantArgument_issue60963() async {
+    await assertErrorsInCode(
+      '''
+class A {
+  int cannotBeConst;
+  A(): cannotBeConst = 0;
+}
+extension type const B(A a) {}
+
+const B b = .new(A());
+''',
+      [
+        error(CompileTimeErrorCode.CONST_WITH_NON_CONST, 108, 3),
+        error(
+          CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE,
+          108,
+          3,
+        ),
+      ],
+    );
+  }
+
   test_field_deferred_issue48991() async {
     newFile('$testPackageLibPath/a.dart', '''
 class A {

pkg/linter/test/rules/prefer_const_constructors_test.dart

@@ -258,6 +258,18 @@ A f(List<int> l) => A(l);
 ''');
   }
 
+  test_cannotBeConst_dotShorthands_issue60963() async {
+    await assertNoDiagnostics(r'''
+class A {
+  int cannotBeConst;
+  A(): cannotBeConst = 0;
+}
+extension type const B(A a) {}
+
+B get b => .new(A());
+''');
+  }
+
   test_cannotBeConst_explicitTypeArgument_typeVariable() async {
     await assertNoDiagnostics(r'''
 class A<T> {