[cfe] Dot shorthands - Const constructors

Parse and build dot shorthand invocations that are constant.
Added a new listener to handle and store the const-ness. It didn't feel right re-using any of the other `beginConstPattern` methods.

Added an error message if invoking a non-const constructor where we expected a const constructor.

Bug: #59758
Change-Id: I8551e3b8f71e89a69d090510bb64694d5e09247d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/414660
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart

@@ -2203,6 +2203,16 @@ class ForwardingListener implements Listener {
   void handleDotShorthandContext(Token token) {
     listener?.handleDotShorthandContext(token);
   }
+
+  @override
+  void beginConstDotShorthand(Token token) {
+    listener?.beginConstDotShorthand(token);
+  }
+
+  @override
+  void endConstDotShorthand(Token token) {
+    listener?.beginConstDotShorthand(token);
+  }
 }
 
 class NullListener extends ForwardingListener {

pkg/_fe_analyzer_shared/lib/src/parser/listener.dart

@@ -2400,4 +2400,10 @@ class Listener implements UnescapeErrorListener {
   void handleDotShorthandHead(Token token) {
     logEvent('DotShorthandHead');
   }
+
+  void beginConstDotShorthand(Token token) {}
+
+  void endConstDotShorthand(Token token) {
+    logEvent('ConstDotShorthand');
+  }
 }

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -5826,13 +5826,24 @@ class Parser {
     return token;
   }
 
+  /// Returns `true` if [period] is a `.` and the next token after is an
+  /// identifier or the `new` keyword.
+  ///
+  /// This indicates the parsing of a dot shorthand e.g. `.parse(42)`.
+  bool _isDotShorthand(Token period) {
+    if (period.isA(TokenType.PERIOD) &&
+        (period.next!.isIdentifier || period.next!.isA(Keyword.NEW))) {
+      return true;
+    }
+    return false;
+  }
+
   Token parsePrecedenceExpression(Token token, int precedence,
       bool allowCascades, ConstantPatternContext constantPatternContext) {
     assert(precedence >= 1);
     assert(precedence <= SELECTOR_PRECEDENCE);
 
-    bool isDotShorthand = token.next!.isA(TokenType.PERIOD) &&
-        (token.next!.next!.isIdentifier || token.next!.next!.isA(Keyword.NEW));
+    bool isDotShorthand = _isDotShorthand(token.next!);
     if (isDotShorthand) {
       // TODO(kallentu): Once the analyzer implementation is done, we can avoid
       // adding a synthetic identifier completely, but currently, the parser
@@ -7463,6 +7474,19 @@ class Parser {
         assert(false, "Expected either [, [] or < but found neither.");
       }
     }
+
+    bool isDotShorthand = _isDotShorthand(token.next!);
+    if (isDotShorthand) {
+      Token dot = token.next!;
+      listener.beginConstDotShorthand(constKeyword);
+      token = parsePrimary(dot, IdentifierContext.expressionContinuation,
+          ConstantPatternContext.explicit);
+      listener.handleDotShorthandHead(dot);
+      listener.handleDotShorthandContext(dot);
+      listener.endConstDotShorthand(constKeyword);
+      return token;
+    }
+
     listener.beginConstExpression(constKeyword);
     token = parseConstructorReference(token, ConstructorReferenceContext.Const,
         /* typeArg = */ potentialTypeArg);

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

@@ -1493,6 +1493,19 @@ class AstBuilder extends StackListener {
         constKeyword: constKeyword, expression: pop() as ExpressionImpl));
   }
 
+  @override
+  void endConstDotShorthand(Token token) {
+    debugEvent("endConstDotShorthand");
+    if (!enabledDotShorthands) {
+      _reportFeatureNotEnabled(
+        feature: ExperimentalFeatures.dot_shorthands,
+        startToken: token,
+      );
+    }
+
+    // TODO(kallentu): Handle dot shorthands.
+  }
+
   @override
   void endConstExpression(Token constKeyword) {
     assert(optional('const', constKeyword));

pkg/front_end/lib/src/kernel/body_builder.dart

@@ -6413,6 +6413,7 @@ class BodyBuilder extends StackListenerImpl
       push(
           new ParserErrorGenerator(this, nameToken, cfe.messageSyntheticToken));
     } else if (type is InvalidExpression) {
+      // Coverage-ignore-block(suite): Not run.
       push(type);
     } else if (type is Expression) {
       push(createInstantiationAndInvocation(
@@ -9982,7 +9983,6 @@ class BodyBuilder extends StackListenerImpl
   void handleDotShorthandContext(Token token) {
     debugEvent("DotShorthandContext");
     if (!libraryFeatures.dotShorthands.isEnabled) {
-      // Coverage-ignore-block(suite): Not run.
       addProblem(
           templateExperimentNotEnabledOffByDefault
               .withArguments(ExperimentalFlag.dotShorthands.name),
@@ -10005,7 +10005,6 @@ class BodyBuilder extends StackListenerImpl
   void handleDotShorthandHead(Token token) {
     debugEvent("DotShorthandHead");
     if (!libraryFeatures.dotShorthands.isEnabled) {
-      // Coverage-ignore-block(suite): Not run.
       addProblem(
           templateExperimentNotEnabledOffByDefault
               .withArguments(ExperimentalFlag.dotShorthands.name),
@@ -10024,14 +10023,31 @@ class BodyBuilder extends StackListenerImpl
       if (selector is InvocationSelector) {
         // e.g. `.parse(2)`
         push(forest.createDotShorthandInvocation(
-            offsetForToken(token), selector.name, selector.arguments));
+            offsetForToken(token), selector.name, selector.arguments,
+            nameOffset: offsetForToken(token.next),
+            isConst: constantContext == ConstantContext.inferred));
       } else if (selector is PropertySelector) {
         // e.g. `.zero`
         push(forest.createDotShorthandPropertyGet(
             offsetForToken(token), selector.name));
       }
     }
   }
+
+  @override
+  void beginConstDotShorthand(Token token) {
+    debugEvent("beginConstDotShorthand");
+    super.push(constantContext);
+    constantContext = ConstantContext.inferred;
+  }
+
+  @override
+  void endConstDotShorthand(Token token) {
+    debugEvent("endConstDotShorthand");
+    Object? dotShorthand = pop();
+    constantContext = pop() as ConstantContext;
+    push(dotShorthand);
+  }
 }
 
 class Operator {

pkg/front_end/lib/src/kernel/expression_generator.dart

@@ -4440,6 +4440,7 @@ class ParserErrorGenerator extends Generator {
   }
 
   @override
+  // Coverage-ignore(suite): Not run.
   Expression qualifiedLookup(Token name) {
     return buildProblem();
   }

pkg/front_end/lib/src/kernel/forest.dart

@@ -934,8 +934,11 @@ class Forest {
   }
 
   DotShorthandInvocation createDotShorthandInvocation(
-      int fileOffset, Name name, Arguments arguments) {
-    return new DotShorthandInvocation(name, arguments)..fileOffset = fileOffset;
+      int fileOffset, Name name, Arguments arguments,
+      {required int nameOffset, required bool isConst}) {
+    return new DotShorthandInvocation(name, arguments, nameOffset,
+        isConst: isConst)
+      ..fileOffset = fileOffset;
   }
 
   DotShorthandPropertyGet createDotShorthandPropertyGet(

pkg/front_end/lib/src/kernel/internal_ast.dart

@@ -3254,11 +3254,13 @@ class DotShorthand extends InternalExpression {
 /// This node could represent a shorthand of a static method or a named
 /// constructor.
 class DotShorthandInvocation extends InternalExpression {
-  Name name;
-
-  Arguments arguments;
+  final Name name;
+  final int nameOffset;
+  final Arguments arguments;
+  final bool isConst;
 
-  DotShorthandInvocation(this.name, this.arguments);
+  DotShorthandInvocation(this.name, this.arguments, this.nameOffset,
+      {required this.isConst});
 
   @override
   ExpressionInferenceResult acceptInference(
@@ -3274,6 +3276,9 @@ class DotShorthandInvocation extends InternalExpression {
   @override
   // Coverage-ignore(suite): Not run.
   void toTextInternal(AstPrinter printer) {
+    if (isConst) {
+      printer.write('const ');
+    }
     printer.write('.');
     printer.writeName(name);
     printer.writeArguments(arguments);

pkg/front_end/lib/src/type_inference/inference_visitor.dart

@@ -12151,15 +12151,40 @@ class InferenceVisitorImpl extends InferenceVisitorBase
       Member? constructor =
           findConstructor(cachedContext, node.name, node.fileOffset);
       if (constructor is Constructor) {
-        // TODO(kallentu): Const constructors.
+        if (!constructor.isConst && node.isConst) {
+          Expression replacement = helper.buildProblem(
+              messageNonConstConstructor,
+              node.nameOffset,
+              node.name.text.length);
+          return new ExpressionInferenceResult(
+              const DynamicType(), replacement);
+        }
+
         expr = new ConstructorInvocation(constructor, node.arguments,
-            isConst: false)
+            isConst: node.isConst)
           ..fileOffset = node.fileOffset;
       } else if (constructor is Procedure) {
         // [constructor] can be a [Procedure] if we have an extension type
-        // constructor.
-        expr = new StaticInvocation(constructor, node.arguments)
-          ..fileOffset = node.fileOffset;
+        // constructor or a redirecting factory constructor.
+        if (!constructor.isConst && node.isConst) {
+          // Coverage-ignore-block(suite): Not run.
+          Expression replacement = helper.buildProblem(
+              messageNonConstConstructor,
+              node.nameOffset,
+              node.name.text.length);
+          return new ExpressionInferenceResult(
+              const DynamicType(), replacement);
+        }
+
+        if (constructor.isRedirectingFactory) {
+          expr = new FactoryConstructorInvocation(constructor, node.arguments,
+              isConst: node.isConst)
+            ..fileOffset = node.fileOffset;
+        } else {
+          expr = new StaticInvocation(constructor, node.arguments,
+              isConst: node.isConst)
+            ..fileOffset = node.fileOffset;
+        }
       } else {
         // Coverage-ignore-block(suite): Not run.
         // TODO(kallentu): This is temporary. Build a problem with an error

pkg/front_end/lib/src/util/parser_ast_helper.dart

@@ -3216,6 +3216,20 @@ abstract class AbstractParserAstListener implements Listener {
         new DotShorthandHeadHandle(ParserAstType.HANDLE, token: token);
     seen(data);
   }
+
+  @override
+  void beginConstDotShorthand(Token token) {
+    ConstDotShorthandBegin data =
+        new ConstDotShorthandBegin(ParserAstType.BEGIN, token: token);
+    seen(data);
+  }
+
+  @override
+  void endConstDotShorthand(Token token) {
+    ConstDotShorthandEnd data =
+        new ConstDotShorthandEnd(ParserAstType.END, token: token);
+    seen(data);
+  }
 }
 
 class ArgumentsBegin extends ParserAstNode {
@@ -10156,6 +10170,36 @@ class DotShorthandHeadHandle extends ParserAstNode {
   R accept<R>(ParserAstVisitor<R> v) => v.visitDotShorthandHeadHandle(this);
 }
 
+class ConstDotShorthandBegin extends ParserAstNode {
+  final Token token;
+
+  ConstDotShorthandBegin(ParserAstType type, {required this.token})
+      : super("ConstDotShorthand", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+
+  @override
+  R accept<R>(ParserAstVisitor<R> v) => v.visitConstDotShorthandBegin(this);
+}
+
+class ConstDotShorthandEnd extends ParserAstNode {
+  final Token token;
+
+  ConstDotShorthandEnd(ParserAstType type, {required this.token})
+      : super("ConstDotShorthand", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+
+  @override
+  R accept<R>(ParserAstVisitor<R> v) => v.visitConstDotShorthandEnd(this);
+}
+
 abstract class ParserAstVisitor<R> {
   R visitArgumentsBegin(ArgumentsBegin node);
   R visitArgumentsEnd(ArgumentsEnd node);
@@ -10552,6 +10596,8 @@ abstract class ParserAstVisitor<R> {
   R visitPatternAssignmentHandle(PatternAssignmentHandle node);
   R visitDotShorthandContextHandle(DotShorthandContextHandle node);
   R visitDotShorthandHeadHandle(DotShorthandHeadHandle node);
+  R visitConstDotShorthandBegin(ConstDotShorthandBegin node);
+  R visitConstDotShorthandEnd(ConstDotShorthandEnd node);
 }
 
 class RecursiveParserAstVisitor implements ParserAstVisitor<void> {
@@ -11970,6 +12016,14 @@ class RecursiveParserAstVisitor implements ParserAstVisitor<void> {
   @override
   void visitDotShorthandHeadHandle(DotShorthandHeadHandle node) =>
       node.visitChildren(this);
+
+  @override
+  void visitConstDotShorthandBegin(ConstDotShorthandBegin node) =>
+      node.visitChildren(this);
+
+  @override
+  void visitConstDotShorthandEnd(ConstDotShorthandEnd node) =>
+      node.visitChildren(this);
 }
 
 class RecursiveParserAstVisitorWithDefaultNodeAsync
@@ -13466,4 +13520,12 @@ class RecursiveParserAstVisitorWithDefaultNodeAsync
   @override
   Future<void> visitDotShorthandHeadHandle(DotShorthandHeadHandle node) =>
       defaultNode(node);
+
+  @override
+  Future<void> visitConstDotShorthandBegin(ConstDotShorthandBegin node) =>
+      defaultNode(node);
+
+  @override
+  Future<void> visitConstDotShorthandEnd(ConstDotShorthandEnd node) =>
+      defaultNode(node);
 }