[analyzer] Dot shorthands: Const constructor invocations.

Added `isConst` and `constKeyword` to `DotShorthandConstructorInvocation`.

`DotShorthandInvocation`s are rewritten to `DotShorthandConstructorInvocation` immediately once we parse the `const` keyword. If we don't resolve to a constructor, we'll produce the `CONST_WITH_UNDEFINED_CONSTRUCTOR` error.

Summary changes in a different CL that follows this one: https://dart-review.googlesource.com/c/sdk/+/424340

co19 tests passing and unit tests added.

Bug: #59835
Change-Id: Ic12cd98cf08009187b8bf32afb62aa026cb7c8c7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/424240
Reviewed-by: Paul Berry <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

pkg/analyzer/api.txt

@@ -721,7 +721,9 @@ package:analyzer/dart/ast/ast.dart:
     semicolon (getter: Token)
     whileKeyword (getter: Token)
   DotShorthandConstructorInvocation (class extends InvocationExpression implements ConstructorReferenceNode, experimental):
+    constKeyword (getter: Token?)
     constructorName (getter: SimpleIdentifier)
+    isConst (getter: bool)
     period (getter: Token)
   DotShorthandInvocation (class extends InvocationExpression, experimental):
     memberName (getter: SimpleIdentifier)

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -5210,28 +5210,43 @@ final class DoStatementImpl extends StatementImpl implements DoStatement {
 abstract final class DotShorthandConstructorInvocation
     extends InvocationExpression
     implements ConstructorReferenceNode {
+  /// The `const` keyword, or `null` if the expression isn't preceded by the
+  /// keyword `const`.
+  Token? get constKeyword;
+
   /// The name of the constructor invocation.
   SimpleIdentifier get constructorName;
 
+  /// Whether this dot shorthand constructor invocation will be evaluated at
+  /// compile-time, either because the keyword `const` was explicitly provided
+  /// or because no keyword was provided and this expression is in a constant
+  /// context.
+  bool get isConst;
+
   /// The token representing the period.
   Token get period;
 }
 
 final class DotShorthandConstructorInvocationImpl
     extends InvocationExpressionImpl
+    with DotShorthandMixin
     implements
         DotShorthandConstructorInvocation,
         RewrittenMethodInvocationImpl {
   @override
   final Token period;
 
+  @override
+  Token? constKeyword;
+
   SimpleIdentifierImpl _constructorName;
 
   @override
   ConstructorElementImpl2? element;
 
   /// Initializes a newly created dot shorthand constructor invocation.
   DotShorthandConstructorInvocationImpl({
+    required this.constKeyword,
     required this.period,
     required SimpleIdentifierImpl constructorName,
     required super.typeArguments,
@@ -5241,7 +5256,7 @@ final class DotShorthandConstructorInvocationImpl
   }
 
   @override
-  Token get beginToken => period;
+  Token get beginToken => constKeyword ?? period;
 
   @override
   SimpleIdentifierImpl get constructorName => _constructorName;
@@ -5256,12 +5271,18 @@ final class DotShorthandConstructorInvocationImpl
   @override
   ExpressionImpl get function => constructorName;
 
+  @override
+  bool get isConst {
+    return constKeyword?.keyword == Keyword.CONST || inConstantContext;
+  }
+
   @override
   Precedence get precedence => Precedence.postfix;
 
   @override
   ChildEntities get _childEntities =>
       ChildEntities()
+        ..addToken('const', constKeyword)
         ..addToken('period', period)
         ..addNode('constructorName', constructorName)
         ..addNode('typeArguments', typeArguments)
@@ -5273,9 +5294,9 @@ final class DotShorthandConstructorInvocationImpl
 
   @override
   void resolveExpression(ResolverVisitor resolver, TypeImpl contextType) {
-    throw StateError(
-      'DotShorthandConstructorInvocationImpl should only appear in fully'
-      ' resolved ASTs',
+    resolver.visitDotShorthandConstructorInvocation(
+      this,
+      contextType: contextType,
     );
   }
 
@@ -10300,7 +10321,7 @@ abstract final class InstanceCreationExpression implements Expression {
   /// The name of the constructor to be invoked.
   ConstructorName get constructorName;
 
-  /// Whether this creation expression is used to invoke a constant constructor,
+  /// Whether this creation expression will be evaluated at compile-time,
   /// either because the keyword `const` was explicitly provided or because no
   /// keyword was provided and this expression is in a constant context.
   bool get isConst;

pkg/analyzer/lib/src/dart/ast/to_source_visitor.dart

@@ -352,6 +352,7 @@ class ToSourceVisitor implements AstVisitor<void> {
   void visitDotShorthandConstructorInvocation(
     DotShorthandConstructorInvocation node,
   ) {
+    _visitToken(node.constKeyword, suffix: ' ');
     _visitToken(node.period);
     _visitNode(node.constructorName);
     _visitNode(node.typeArguments);

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

@@ -875,6 +875,30 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
     );
   }
 
+  @override
+  Constant visitDotShorthandConstructorInvocation(
+    covariant DotShorthandConstructorInvocationImpl node,
+  ) {
+    var constructor = node.constructorName.element;
+    if (constructor is ConstructorElementMixin2) {
+      return _evaluationEngine.evaluateAndFormatErrorsInConstructorCall(
+        _library,
+        node,
+        constructor.returnType.typeArguments,
+        node.argumentList.arguments,
+        constructor.asElement,
+        this,
+      );
+    }
+
+    // Couldn't resolve the constructor so we can't compute a value.  No
+    // problem - the error has already been reported.
+    return InvalidConstant.forEntity(
+      entity: node,
+      errorCode: CompileTimeErrorCode.INVALID_CONSTANT,
+    );
+  }
+
   @override
   Constant visitDotShorthandPropertyAccess(
     covariant DotShorthandPropertyAccessImpl node,

pkg/analyzer/lib/src/dart/resolver/instance_creation_expression_resolver.dart

@@ -3,8 +3,10 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 /// A resolver for [InstanceCreationExpression] and
@@ -71,6 +73,25 @@ class InstanceCreationExpressionResolver {
 
     // TODO(kallentu): Support other context types
     if (dotShorthandContextType is InterfaceTypeImpl) {
+      // This branch will be true if we're resolving an explicitly marked
+      // const constructor invocation. It's completely unresolved, unlike a
+      // rewritten [DotShorthandConstructorInvocation] that resulted from
+      // resolving a [DotShorthandInvocation].
+      if (node.element == null) {
+        var contextElement = dotShorthandContextType.element3;
+        if (contextElement.getNamedConstructor2(node.constructorName.name)
+            case ConstructorElementImpl2 element?
+            when element.isAccessibleIn2(_resolver.definingLibrary)) {
+          node.element = element;
+        } else {
+          _resolver.errorReporter.atNode(
+            node.constructorName,
+            CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR,
+            arguments: [contextType, node.constructorName.name],
+          );
+        }
+      }
+
       _resolveDotShorthandConstructorInvocation(
         node,
         contextType: contextType,

pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart

@@ -151,9 +151,8 @@ class DotShorthandConstructorInvocationInferrer
   @override
   SimpleIdentifierImpl get _errorEntity => node.constructorName;
 
-  // TODO(kallentu): Implement const constructors.
   @override
-  bool get _isConst => false;
+  bool get _isConst => node.isConst;
 
   @override
   bool get _needsTypeArgumentBoundsCheck => true;

pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart

@@ -1272,8 +1272,10 @@ class MethodInvocationResolver with ScopeHelpers {
     if (receiver.getNamedConstructor2(name)
         case ConstructorElementImpl2 element?
         when element.isAccessibleIn2(_resolver.definingLibrary)) {
-      nameNode.element = element;
+      // TODO(kallentu): Produce an error if there are type arguments for this
+      // constructor.
       var replacement = DotShorthandConstructorInvocationImpl(
+        constKeyword: null,
         period: node.period,
         constructorName: nameNode,
         typeArguments: node.typeArguments,

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -1619,7 +1619,17 @@ class AstBuilder extends StackListener {
       );
     }
 
-    // TODO(kallentu): Handle dot shorthands.
+    var dotShorthand = pop() as DotShorthandInvocationImpl;
+    // TODO(kallentu): Report error if there are type arguments here.
+    push(
+      DotShorthandConstructorInvocationImpl(
+        constKeyword: token,
+        period: dotShorthand.period,
+        constructorName: dotShorthand.memberName,
+        typeArguments: dotShorthand.typeArguments,
+        argumentList: dotShorthand.argumentList,
+      )..isDotShorthand = dotShorthand.isDotShorthand,
+    );
   }
 
   @override

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

@@ -646,6 +646,20 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     super.visitDefaultFormalParameter(node);
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+    DotShorthandConstructorInvocation node,
+  ) {
+    if (node.isConst) {
+      _checkForConstWithNonConst(
+        node,
+        node.constructorName.element as ConstructorElement?,
+        node.constKeyword,
+      );
+    }
+    super.visitDotShorthandConstructorInvocation(node);
+  }
+
   @override
   void visitEnumConstantDeclaration(
     covariant EnumConstantDeclarationImpl node,
@@ -1081,7 +1095,11 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       _constArgumentsVerifier.visitInstanceCreationExpression(node);
       _checkUseVerifier.checkInstanceCreationExpression(node);
       if (node.isConst) {
-        _checkForConstWithNonConst(node);
+        _checkForConstWithNonConst(
+          node,
+          node.constructorName.element,
+          node.keyword,
+        );
         _checkForConstWithUndefinedConstructor(
           node,
           constructorName,
@@ -2788,16 +2806,19 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
   /// Verify that the given 'const' instance creation [expression] is not being
   /// invoked on a constructor that is not 'const'.
   ///
-  /// This method assumes that the instance creation was tested to be 'const'
-  /// before being called.
+  /// This method assumes that the instance creation or dot shorthand
+  /// constructor invocation was tested to be 'const' before being called.
   ///
   /// See [CompileTimeErrorCode.CONST_WITH_NON_CONST].
-  void _checkForConstWithNonConst(InstanceCreationExpression expression) {
-    var constructorElement = expression.constructorName.element;
+  void _checkForConstWithNonConst(
+    Expression expression,
+    ConstructorElement? constructorElement,
+    Token? keyword,
+  ) {
     if (constructorElement != null && !constructorElement.isConst) {
-      if (expression.keyword != null) {
+      if (keyword != null) {
         errorReporter.atToken(
-          expression.keyword!,
+          keyword,
           CompileTimeErrorCode.CONST_WITH_NON_CONST,
         );
       } else {

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

@@ -2410,6 +2410,30 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     inferenceLogWriter?.exitStatement(node);
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+    covariant DotShorthandConstructorInvocationImpl node, {
+    TypeImpl contextType = UnknownInferredType.instance,
+  }) {
+    inferenceLogWriter?.enterExpression(node, contextType);
+
+    // If [isDotShorthand] is set, cache the context type for resolution.
+    if (isDotShorthand(node)) {
+      pushDotShorthandContext(node, SharedTypeSchemaView(contextType));
+    }
+
+    _instanceCreationExpressionResolver.resolveDotShorthand(
+      node,
+      contextType: contextType,
+    );
+
+    if (isDotShorthand(node)) {
+      popDotShorthandContext();
+    }
+
+    inferenceLogWriter?.exitExpression(node);
+  }
+
   @override
   void visitDotShorthandInvocation(
     covariant DotShorthandInvocationImpl node, {