[parser] Initial parsing of dot shorthands.

Doing some initial work for parsing dot shorthands.

The listeners in the CFE and analyzer will report an extra error if the experiment is not turned on. The compilation should still fail and produce errors, but it won't crash.

If you turn on the experiment, the parsing will crash, but I'd like to get this in so I can modularly work on the CFE and analyzer separately.

Bug: #59758, #59835
Change-Id: I262b0bd5cffc8e5e04ac79c76454b6e355779ade
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/409540
Reviewed-by: Jens Johansen <[email protected]>
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: kallentu

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

@@ -2193,6 +2193,16 @@ class ForwardingListener implements Listener {
   void handleNoPrimaryConstructor(Token token, Token? constKeyword) {
     listener?.handleNoPrimaryConstructor(token, constKeyword);
   }
+
+  @override
+  void handleDotShorthandHead(Token token) {
+    listener?.handleDotShorthandHead(token);
+  }
+
+  @override
+  void handleDotShorthandContext(Token token) {
+    listener?.handleDotShorthandContext(token);
+  }
 }
 
 class NullListener extends ForwardingListener {

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

@@ -2392,4 +2392,12 @@ class Listener implements UnescapeErrorListener {
   void handlePatternAssignment(Token equals) {
     logEvent("PatternAssignment");
   }
+
+  void handleDotShorthandContext(Token token) {
+    logEvent("DotShorthandContext");
+  }
+
+  void handleDotShorthandHead(Token token) {
+    logEvent('DotShorthandHead');
+  }
 }

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

@@ -5830,7 +5830,13 @@ class Parser {
       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));
+    // TODO(kallentu): Once the parser handles dot shorthands by default,
+    // we don't need to parse for an error here.
     token = parseUnaryExpression(token, allowCascades, constantPatternContext);
+
     Token bangToken = token;
     if (token.next!.isA(TokenType.BANG)) {
       bangToken = token.next!;
@@ -5854,6 +5860,17 @@ class Parser {
       }
     }
 
+    if (isDotShorthand) {
+      Token dot = token.next!;
+      token = _parsePrecedenceExpressionLoop(SELECTOR_PRECEDENCE, allowCascades,
+          typeArg, token, constantPatternContext,
+          isDotShorthand: true);
+
+      // The entire shorthand is parsed at this point.
+      listener.handleDotShorthandContext(dot);
+      return token;
+    }
+
     return _parsePrecedenceExpressionLoop(
         precedence, allowCascades, typeArg, token, constantPatternContext);
   }
@@ -5863,7 +5880,8 @@ class Parser {
       bool allowCascades,
       TypeParamOrArgInfo typeArg,
       Token token,
-      ConstantPatternContext constantPatternContext) {
+      ConstantPatternContext constantPatternContext,
+      {bool isDotShorthand = false}) {
     Token next = token.next!;
     TokenType type = next.type;
     int tokenLevel = _computePrecedence(next, forPattern: false);
@@ -5962,11 +5980,16 @@ class Parser {
             // should just call [parseUnaryExpression] directly. However, a
             // unary expression isn't legal after a period, so we call
             // [parsePrimary] instead.
-            token = parsePrimary(
-                token.next!,
-                IdentifierContext.expressionContinuation,
+            Token dot = token.next!;
+            token = parsePrimary(dot, IdentifierContext.expressionContinuation,
                 constantPatternContext);
-            listener.handleEndingBinaryExpression(operator, token);
+
+            if (isDotShorthand) {
+              listener.handleDotShorthandHead(dot);
+              isDotShorthand = false;
+            } else {
+              listener.handleEndingBinaryExpression(operator, token);
+            }
 
             Token bangToken = token;
             if (token.next!.isA(TokenType.BANG)) {

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

@@ -160,6 +160,9 @@ class AstBuilder extends StackListener {
   /// `true` if null-aware elements is enabled
   final bool enableNullAwareElements;
 
+  /// `true` if dot-shorthands is enabled
+  final bool enabledDotShorthands;
+
   /// `true` if digit-separators is enabled.
   final bool _enableDigitSeparators;
 
@@ -196,6 +199,7 @@ class AstBuilder extends StackListener {
         enableClassModifiers = _featureSet.isEnabled(Feature.class_modifiers),
         enableNullAwareElements =
             _featureSet.isEnabled(Feature.null_aware_elements),
+        enabledDotShorthands = _featureSet.isEnabled(Feature.dot_shorthands),
         _enableDigitSeparators =
             _featureSet.isEnabled(Feature.digit_separators),
         uri = uri ?? fileUri;
@@ -4038,6 +4042,35 @@ class AstBuilder extends StackListener {
     );
   }
 
+  @override
+  void handleDotShorthandContext(Token token) {
+    debugEvent("DotShorthandContext");
+    if (!enabledDotShorthands) {
+      _reportFeatureNotEnabled(
+        feature: ExperimentalFeatures.dot_shorthands,
+        startToken: token,
+      );
+    }
+
+    // TODO(kallentu): Handle dot shorthands.
+  }
+
+  @override
+  void handleDotShorthandHead(Token token) {
+    debugEvent("DotShorthandHead");
+    if (!enabledDotShorthands) {
+      _reportFeatureNotEnabled(
+        feature: ExperimentalFeatures.dot_shorthands,
+        startToken: token,
+      );
+
+      // Recovery.
+      pop();
+    }
+
+    // TODO(kallentu): Handle dot shorthands.
+  }
+
   @override
   void handleDottedName(int count, Token firstIdentifier) {
     assert(firstIdentifier.isIdentifier);

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

@@ -9974,6 +9974,37 @@ class BodyBuilder extends StackListenerImpl
     push(
         forest.createPatternAssignment(equals.charOffset, pattern, expression));
   }
+
+  @override
+  // Coverage-ignore(suite): Not run.
+  void handleDotShorthandContext(Token token) {
+    debugEvent("DotShorthandContext");
+    if (!libraryFeatures.dotShorthands.isEnabled) {
+      addProblem(
+          templateExperimentNotEnabledOffByDefault
+              .withArguments(ExperimentalFlag.dotShorthands.name),
+          token.offset,
+          token.length);
+    }
+  }
+
+  @override
+  // Coverage-ignore(suite): Not run.
+  void handleDotShorthandHead(Token token) {
+    debugEvent("DotShorthandHead");
+    if (!libraryFeatures.dotShorthands.isEnabled) {
+      addProblem(
+          templateExperimentNotEnabledOffByDefault
+              .withArguments(ExperimentalFlag.dotShorthands.name),
+          token.offset,
+          token.length);
+
+      // Recovery, avoid crashing with an extra selector.
+      pop();
+    }
+
+    // TODO(kallentu): Handle dot shorthands.
+  }
 }
 
 class Operator {

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

@@ -3202,6 +3202,20 @@ abstract class AbstractParserAstListener implements Listener {
         new PatternAssignmentHandle(ParserAstType.HANDLE, equals: equals);
     seen(data);
   }
+
+  @override
+  void handleDotShorthandContext(Token token) {
+    DotShorthandContextHandle data =
+        new DotShorthandContextHandle(ParserAstType.HANDLE, token: token);
+    seen(data);
+  }
+
+  @override
+  void handleDotShorthandHead(Token token) {
+    DotShorthandHeadHandle data =
+        new DotShorthandHeadHandle(ParserAstType.HANDLE, token: token);
+    seen(data);
+  }
 }
 
 class ArgumentsBegin extends ParserAstNode {
@@ -10112,6 +10126,36 @@ class PatternAssignmentHandle extends ParserAstNode {
   R accept<R>(ParserAstVisitor<R> v) => v.visitPatternAssignmentHandle(this);
 }
 
+class DotShorthandContextHandle extends ParserAstNode {
+  final Token token;
+
+  DotShorthandContextHandle(ParserAstType type, {required this.token})
+      : super("DotShorthandContext", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+
+  @override
+  R accept<R>(ParserAstVisitor<R> v) => v.visitDotShorthandContextHandle(this);
+}
+
+class DotShorthandHeadHandle extends ParserAstNode {
+  final Token token;
+
+  DotShorthandHeadHandle(ParserAstType type, {required this.token})
+      : super("DotShorthandHead", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+
+  @override
+  R accept<R>(ParserAstVisitor<R> v) => v.visitDotShorthandHeadHandle(this);
+}
+
 abstract class ParserAstVisitor<R> {
   R visitArgumentsBegin(ArgumentsBegin node);
   R visitArgumentsEnd(ArgumentsEnd node);
@@ -10506,6 +10550,8 @@ abstract class ParserAstVisitor<R> {
   R visitPatternVariableDeclarationStatementHandle(
       PatternVariableDeclarationStatementHandle node);
   R visitPatternAssignmentHandle(PatternAssignmentHandle node);
+  R visitDotShorthandContextHandle(DotShorthandContextHandle node);
+  R visitDotShorthandHeadHandle(DotShorthandHeadHandle node);
 }
 
 class RecursiveParserAstVisitor implements ParserAstVisitor<void> {
@@ -11916,6 +11962,14 @@ class RecursiveParserAstVisitor implements ParserAstVisitor<void> {
   @override
   void visitPatternAssignmentHandle(PatternAssignmentHandle node) =>
       node.visitChildren(this);
+
+  @override
+  void visitDotShorthandContextHandle(DotShorthandContextHandle node) =>
+      node.visitChildren(this);
+
+  @override
+  void visitDotShorthandHeadHandle(DotShorthandHeadHandle node) =>
+      node.visitChildren(this);
 }
 
 class RecursiveParserAstVisitorWithDefaultNodeAsync
@@ -13404,4 +13458,12 @@ class RecursiveParserAstVisitorWithDefaultNodeAsync
   @override
   Future<void> visitPatternAssignmentHandle(PatternAssignmentHandle node) =>
       defaultNode(node);
+
+  @override
+  Future<void> visitDotShorthandContextHandle(DotShorthandContextHandle node) =>
+      defaultNode(node);
+
+  @override
+  Future<void> visitDotShorthandHeadHandle(DotShorthandHeadHandle node) =>
+      defaultNode(node);
 }

pkg/front_end/parser_testcases/dot_shorthands/syntax.dart

@@ -0,0 +1,5 @@
+enum Color { red, blue, green }
+
+void main() {
+  Color c = .red;
+}

pkg/front_end/parser_testcases/dot_shorthands/syntax.dart.expect

@@ -0,0 +1,87 @@
+Problems reported:
+
+parser/dot_shorthands/syntax:4:13: Expected an identifier, but got '.'.
+  Color c = .red;
+            ^
+
+beginCompilationUnit(enum)
+  beginMetadataStar(enum)
+  endMetadataStar(0)
+  beginUncategorizedTopLevelDeclaration(enum)
+    handleIdentifier(Color, enumDeclaration)
+    beginEnum(enum)
+      handleNoTypeVariables({)
+      handleEnumNoWithClause()
+      handleImplements(null, 0)
+      handleEnumHeader(null, enum, {)
+      beginMetadataStar(red)
+      endMetadataStar(0)
+      handleIdentifier(red, enumValueDeclaration)
+      handleNoTypeNameInConstructorReference(,)
+      beginConstructorReference(red)
+        handleNoTypeArguments(,)
+        handleNoConstructorReferenceContinuationAfterTypeArguments(red)
+      endConstructorReference(red, null, red, ConstructorReferenceContext.Const)
+      handleNoArguments(red)
+      handleEnumElement({, null)
+      beginMetadataStar(blue)
+      endMetadataStar(0)
+      handleIdentifier(blue, enumValueDeclaration)
+      handleNoTypeNameInConstructorReference(,)
+      beginConstructorReference(blue)
+        handleNoTypeArguments(,)
+        handleNoConstructorReferenceContinuationAfterTypeArguments(blue)
+      endConstructorReference(blue, null, blue, ConstructorReferenceContext.Const)
+      handleNoArguments(blue)
+      handleEnumElement(,, null)
+      beginMetadataStar(green)
+      endMetadataStar(0)
+      handleIdentifier(green, enumValueDeclaration)
+      handleNoTypeNameInConstructorReference(})
+      beginConstructorReference(green)
+        handleNoTypeArguments(})
+        handleNoConstructorReferenceContinuationAfterTypeArguments(green)
+      endConstructorReference(green, null, green, ConstructorReferenceContext.Const)
+      handleNoArguments(green)
+      handleEnumElement(,, null)
+      handleEnumElements(}, 3)
+    endEnum(enum, enum, {, 0, })
+  endTopLevelDeclaration(})
+  beginMetadataStar(void)
+  endMetadataStar(0)
+  beginTopLevelMember(void)
+    beginTopLevelMethod(}, null, null)
+      handleVoidKeyword(void)
+      handleIdentifier(main, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+        beginMetadataStar(Color)
+        endMetadataStar(0)
+        handleIdentifier(Color, typeReference)
+        handleNoTypeArguments(c)
+        handleType(Color, null)
+        beginVariablesDeclaration(c, null, null)
+          handleIdentifier(c, localVariableDeclaration)
+          beginInitializedIdentifier(c)
+            beginVariableInitializer(=)
+              handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '.'., Try inserting an identifier before '.'., {lexeme: .}], ., .)
+              handleIdentifier(, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(, )
+              handleIdentifier(red, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(red, red)
+              handleDotShorthandHead(.)
+              handleDotShorthandContext(.)
+            endVariableInitializer(=)
+          endInitializedIdentifier(c)
+        endVariablesDeclaration(1, ;)
+      endBlockFunctionBody(1, {, })
+    endTopLevelMethod(void, null, })
+  endTopLevelDeclaration(})
+endCompilationUnit(2, )