[analyzer] Dot shorthands: Update and add tests for const dot shorthands.

Updated the AST binary reader/writer to handle dot shorthand invocations otherwise we crash when we try to evaluate a method invocation. Added a test for that in `const_test.dart`.

Added a plethora of tests in `evaluation_test.dart` which led me to find a bug with not carrying over the `isDotShorthand` flag when we convert from a method invocation to a constructor invocation.

Unit tests passing.

Bug: #59835
Change-Id: Ide1cb7cffc0285ed7d54e9f7bc641d0d28c1d2e2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/437881
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -110,7 +110,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 487;
+  static const int DATA_VERSION = 488;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

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

@@ -7197,8 +7197,17 @@ final class DotShorthandInvocationImpl extends InvocationExpressionImpl
 
 base mixin DotShorthandMixin on ExpressionImpl {
   /// Whether the AST node is a dot shorthand and has a dot shorthand head
-  /// ([DotShorthandInvocation] or [DotShorthandPropertyAccess]) as its
+  /// ([DotShorthandInvocation], [DotShorthandConstructorInvocation] or
+  /// [DotShorthandPropertyAccess]) as its
   /// inner-most target.
+  ///
+  /// This is `false` and remains `false` when there is no dot shorthand head as
+  /// its inner-most target. When we are parsing and notice that we have a dot
+  /// shorthand head, we flip this flag to `true` and it remains `true` for that
+  /// expression.
+  ///
+  /// We use this flag to determine the correct context type to cache. This
+  /// cached context type is then used to resolve the dot shorthand head.
   bool isDotShorthand = false;
 }
 

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

@@ -920,6 +920,11 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
     );
   }
 
+  @override
+  Constant visitDotShorthandInvocation(DotShorthandInvocation node) {
+    return _invalidConstantForMethodInvocation(node);
+  }
+
   @override
   Constant visitDotShorthandPropertyAccess(
     covariant DotShorthandPropertyAccessImpl node,
@@ -1150,20 +1155,7 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
       }
     }
 
-    // Some methods aren't resolved by the time we are evaluating it. We'll mark
-    // it and return immediately.
-    if (node.staticType is InvalidType) {
-      return InvalidConstant.forEntity(
-        entity: node,
-        diagnosticCode: CompileTimeErrorCode.INVALID_CONSTANT,
-        isUnresolved: true,
-      );
-    }
-
-    return InvalidConstant.forEntity(
-      entity: node,
-      diagnosticCode: CompileTimeErrorCode.CONST_EVAL_METHOD_INVOCATION,
-    );
+    return _invalidConstantForMethodInvocation(node);
   }
 
   @override
@@ -2221,6 +2213,25 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
     return value;
   }
 
+  // Common invalid constants for method invocations and dot shorthand
+  // invocations.
+  Constant _invalidConstantForMethodInvocation(Expression node) {
+    // Some methods aren't resolved by the time we are evaluating it. We'll mark
+    // it and return immediately.
+    if (node.staticType is InvalidType) {
+      return InvalidConstant.forEntity(
+        entity: node,
+        diagnosticCode: CompileTimeErrorCode.INVALID_CONSTANT,
+        isUnresolved: true,
+      );
+    }
+
+    return InvalidConstant.forEntity(
+      entity: node,
+      diagnosticCode: CompileTimeErrorCode.CONST_EVAL_METHOD_INVOCATION,
+    );
+  }
+
   /// Returns the first not-potentially constant error found with [node] or
   /// `null` if there are none.
   InvalidConstant? _reportNotPotentialConstants(AstNode node) {

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

@@ -1288,13 +1288,16 @@ class MethodInvocationResolver with ScopeHelpers {
     // [DotShorthandConstructorInvocation].
     if (receiver.getNamedConstructor2(name) case ConstructorElementImpl element?
         when element.isAccessibleIn2(_resolver.definingLibrary)) {
-      var replacement = DotShorthandConstructorInvocationImpl(
-        constKeyword: null,
-        period: node.period,
-        constructorName: nameNode,
-        typeArguments: node.typeArguments,
-        argumentList: node.argumentList,
-      )..element = element;
+      var replacement =
+          DotShorthandConstructorInvocationImpl(
+              constKeyword: null,
+              period: node.period,
+              constructorName: nameNode,
+              typeArguments: node.typeArguments,
+              argumentList: node.argumentList,
+            )
+            ..element = element
+            ..isDotShorthand = node.isDotShorthand;
       _resolver.replaceExpression(node, replacement);
       _resolver.flowAnalysis.transferTestData(node, replacement);
       return replacement;

pkg/analyzer/lib/src/summary2/ast_binary_reader.dart

@@ -65,6 +65,8 @@ class AstBinaryReader {
         return _readDefaultFormalParameter();
       case Tag.DotShorthandConstructorInvocation:
         return _readDotShorthandConstructorInvocation();
+      case Tag.DotShorthandInvocation:
+        return _readDotShorthandInvocation();
       case Tag.DotShorthandPropertyAccess:
         return _readDotShorthandPropertyAccess();
       case Tag.DottedName:
@@ -482,6 +484,20 @@ class AstBinaryReader {
     return node;
   }
 
+  DotShorthandInvocation _readDotShorthandInvocation() {
+    var memberName = readNode() as SimpleIdentifierImpl;
+    var typeArguments = _readOptionalNode() as TypeArgumentListImpl?;
+    var arguments = readNode() as ArgumentListImpl;
+    var node = DotShorthandInvocationImpl(
+      period: Tokens.period(),
+      memberName: memberName,
+      typeArguments: typeArguments,
+      argumentList: arguments,
+    );
+    _readInvocationExpression(node);
+    return node;
+  }
+
   DotShorthandPropertyAccess _readDotShorthandPropertyAccess() {
     var propertyName = readNode() as SimpleIdentifierImpl;
     var node = DotShorthandPropertyAccessImpl(

pkg/analyzer/lib/src/summary2/ast_binary_tag.dart

@@ -52,6 +52,7 @@ class Tag {
   static const int DeclaredIdentifier = 90;
   static const int DefaultFormalParameter = 8;
   static const int DotShorthandConstructorInvocation = 114;
+  static const int DotShorthandInvocation = 115;
   static const int DotShorthandPropertyAccess = 113;
   static const int DottedName = 47;
   static const int DoubleLiteral = 9;

pkg/analyzer/lib/src/summary2/ast_binary_writer.dart

@@ -239,6 +239,13 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
     _storeExpression(node);
   }
 
+  @override
+  void visitDotShorthandInvocation(DotShorthandInvocation node) {
+    _writeByte(Tag.DotShorthandInvocation);
+    _writeNode(node.memberName);
+    _storeInvocationExpression(node);
+  }
+
   @override
   void visitDotShorthandPropertyAccess(DotShorthandPropertyAccess node) {
     _writeByte(Tag.DotShorthandPropertyAccess);