[analyzer] Dot shorthands: Store DotShorthandsConstructorInvocation in summaries.

Updates the summary reading and writing to handle constructor invocations.

Once this was updated, it uncovered some errors in the constant evaluation so I added some logic to the potential-constant checker to handle `DotShorthandsConstructorInvocation`s. Tests cover this new behavior.

`equality_ctor_test` and `constructor_future_or_test` language tests passing. Added unit tests.

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

Author: kallentu

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

@@ -100,7 +100,7 @@ import 'package:meta/meta.dart';
 // 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 = 455;
+  static const int DATA_VERSION = 456;
 
   /// 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/constant/potentially_constant.dart

@@ -76,6 +76,13 @@ class _Collector {
       return _identifier(node.propertyName);
     }
 
+    if (node is DotShorthandConstructorInvocation) {
+      if (!node.isConst) {
+        nodes.add(node);
+      }
+      return;
+    }
+
     if (node is StringInterpolation) {
       for (var component in node.elements) {
         if (component is InterpolationExpression) {

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

@@ -63,6 +63,8 @@ class AstBinaryReader {
         return _readDeclaredIdentifier();
       case Tag.DefaultFormalParameter:
         return _readDefaultFormalParameter();
+      case Tag.DotShorthandConstructorInvocation:
+        return _readDotShorthandConstructorInvocation();
       case Tag.DotShorthandPropertyAccess:
         return _readDotShorthandPropertyAccess();
       case Tag.DottedName:
@@ -462,6 +464,23 @@ class AstBinaryReader {
     return node;
   }
 
+  DotShorthandConstructorInvocation _readDotShorthandConstructorInvocation() {
+    var flags = _readByte();
+    var constructorName = readNode() as SimpleIdentifierImpl;
+    var argumentList = readNode() as ArgumentListImpl;
+
+    var node = DotShorthandConstructorInvocationImpl(
+      constKeyword: AstBinaryFlags.isConst(flags) ? Tokens.const_() : null,
+      period: Tokens.period(),
+      constructorName: constructorName,
+      typeArguments: null,
+      argumentList: argumentList,
+    );
+    _readExpressionResolution(node);
+    _resolveNamedExpressions(node.constructorName.element, node.argumentList);
+    return node;
+  }
+
   DotShorthandPropertyAccess _readDotShorthandPropertyAccess() {
     var propertyName = readNode() as SimpleIdentifierImpl;
     var node = DotShorthandPropertyAccessImpl(

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

@@ -40,8 +40,9 @@ class Tag {
   static const int ConstructorReference = 101;
   static const int DeclaredIdentifier = 90;
   static const int DefaultFormalParameter = 8;
-  static const int DottedName = 47;
+  static const int DotShorthandConstructorInvocation = 114;
   static const int DotShorthandPropertyAccess = 113;
+  static const int DottedName = 47;
   static const int DoubleLiteral = 9;
   static const int ExtensionOverride = 87;
   static const int FieldFormalParameter = 16;

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

@@ -224,6 +224,19 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
     _writeOptionalNode(defaultValue);
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+    DotShorthandConstructorInvocation node,
+  ) {
+    _writeByte(Tag.DotShorthandConstructorInvocation);
+    _writeByte(
+      AstBinaryFlags.encode(isConst: node.constKeyword?.type == Keyword.CONST),
+    );
+    _writeNode(node.constructorName);
+    _writeNode(node.argumentList);
+    _storeExpression(node);
+  }
+
   @override
   void visitDotShorthandPropertyAccess(DotShorthandPropertyAccess node) {
     _writeByte(Tag.DotShorthandPropertyAccess);

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

@@ -2174,6 +2174,28 @@ abstract class _OffsetsAstVisitor extends RecursiveAstVisitor<void> {
     node.name?.accept(this);
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+    DotShorthandConstructorInvocation node,
+  ) {
+    _tokenOrNull(node.constKeyword);
+    _tokenOrNull(node.period);
+    node.constructorName.accept(this);
+    node.argumentList.accept(this);
+  }
+
+  /// When we read from bytes, [DotShorthandInvocation]s are not rewritten to
+  /// [DotShorthandConstructorInvocation]s when they're resolved to be
+  /// constructor invocations. However, since the tokens happen to be the same
+  /// between the two in this case, we have the same offsets.
+  @override
+  void visitDotShorthandInvocation(DotShorthandInvocation node) {
+    _tokenOrNull(node.period);
+    node.memberName.accept(this);
+    node.typeArguments?.accept(this);
+    node.argumentList.accept(this);
+  }
+
   @override
   void visitDotShorthandPropertyAccess(DotShorthandPropertyAccess node) {
     _tokenOrNull(node.period);

pkg/analyzer/lib/src/test_utilities/find_node.dart

@@ -363,6 +363,12 @@ class FindNode {
     return _node(search, (n) => n is DoStatement);
   }
 
+  DotShorthandConstructorInvocation dotShorthandConstructorInvocation(
+    String search,
+  ) {
+    return _node(search, (n) => n is DotShorthandConstructorInvocation);
+  }
+
   DotShorthandInvocation dotShorthandInvocation(String search) {
     return _node(search, (n) => n is DotShorthandInvocation);
   }

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

@@ -500,6 +500,55 @@ class B {}
 ''', () => findNode.constructorReference('B.new'));
   }
 
+  test_dotShorthandConstructorInvocation_const() async {
+    await _assertConst(r'''
+class A {
+  const A();
+}
+
+const A x = .new();
+''', () => findNode.dotShorthandConstructorInvocation('.new()'));
+  }
+
+  test_dotShorthandConstructorInvocation_nonConst() async {
+    await _assertNotConst(
+      r'''
+class A {
+  const A();
+}
+
+A x = .new();
+''',
+      () => _xInitializer(),
+      () => [findNode.dotShorthandConstructorInvocation('.new()')],
+    );
+  }
+
+  test_dotShorthandPropertyAccess_const() async {
+    await _assertConst(r'''
+class A {
+  static const A a = A();
+  const A();
+}
+
+const A x = .a;
+''', () => findNode.dotShorthandPropertyAccess('.a'));
+  }
+
+  test_dotShorthandPropertyAccess_nonConst() async {
+    await _assertNotConst(
+      r'''
+class A {
+  static A a = A();
+}
+
+A x = .a;
+''',
+      () => _xInitializer(),
+      () => [findNode.simple('a;')],
+    );
+  }
+
   test_functionReference_explicitTypeArguments() async {
     await _assertConst('''
 class A {

pkg/analyzer/test/src/dart/resolution/dot_shorthand_constructor_invocation_test.dart

@@ -86,6 +86,41 @@ DotShorthandConstructorInvocation
 ''');
   }
 
+  test_const_assert() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  final int x;
+  const C.named(this.x);
+}
+
+class CAssert {
+  const CAssert.regular(C ctor)
+    : assert(ctor == const .named(1));
+}
+''');
+
+    var node = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(node, r'''
+DotShorthandConstructorInvocation
+  const: const
+  period: .
+  constructorName: SimpleIdentifier
+    token: named
+    element: <testLibraryFragment>::@class::C::@constructor::named#element
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      IntegerLiteral
+        literal: 1
+        correspondingParameter: <testLibraryFragment>::@class::C::@constructor::named::@parameter::x#element
+        staticType: int
+    rightParenthesis: )
+  correspondingParameter: dart:core::<fragment>::@class::Object::@method::==::@parameter::other#element
+  staticType: C
+''');
+  }
+
   test_const_inConstantContext() async {
     await assertNoErrorsInCode(r'''
 class C {

pkg/analyzer/test/src/summary/elements/const_test.dart

@@ -588,6 +588,141 @@ library
 ''');
   }
 
+  test_const_dotShorthand_constructor_explicit() async {
+    var library = await buildLibrary(r'''
+class A {
+  const A();
+}
+
+const A a = const .new();
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        class A @6
+          reference: <testLibraryFragment>::@class::A
+          element: <testLibrary>::@class::A
+          constructors
+            const new
+              reference: <testLibraryFragment>::@class::A::@constructor::new
+              element: <testLibraryFragment>::@class::A::@constructor::new#element
+              typeName: A
+              typeNameOffset: 18
+      topLevelVariables
+        hasInitializer a @34
+          reference: <testLibraryFragment>::@topLevelVariable::a
+          element: <testLibrary>::@topLevelVariable::a
+          initializer: expression_0
+            DotShorthandConstructorInvocation
+              const: const @38
+              period: . @44
+              constructorName: SimpleIdentifier
+                token: new @45
+                element: <testLibraryFragment>::@class::A::@constructor::new#element
+                staticType: null
+              argumentList: ArgumentList
+                leftParenthesis: ( @48
+                rightParenthesis: ) @49
+              staticType: A
+          getter2: <testLibraryFragment>::@getter::a
+      getters
+        synthetic get a
+          reference: <testLibraryFragment>::@getter::a
+          element: <testLibraryFragment>::@getter::a#element
+  classes
+    class A
+      reference: <testLibrary>::@class::A
+      firstFragment: <testLibraryFragment>::@class::A
+      constructors
+        const new
+          firstFragment: <testLibraryFragment>::@class::A::@constructor::new
+  topLevelVariables
+    const hasInitializer a
+      reference: <testLibrary>::@topLevelVariable::a
+      firstFragment: <testLibraryFragment>::@topLevelVariable::a
+      type: A
+      constantInitializer
+        fragment: <testLibraryFragment>::@topLevelVariable::a
+        expression: expression_0
+      getter: <testLibraryFragment>::@getter::a#element
+  getters
+    synthetic static get a
+      firstFragment: <testLibraryFragment>::@getter::a
+      returnType: A
+''');
+  }
+
+  test_const_dotShorthand_constructor_implicit() async {
+    var library = await buildLibrary(r'''
+class A {
+  const A();
+}
+
+const A a = .new();
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        class A @6
+          reference: <testLibraryFragment>::@class::A
+          element: <testLibrary>::@class::A
+          constructors
+            const new
+              reference: <testLibraryFragment>::@class::A::@constructor::new
+              element: <testLibraryFragment>::@class::A::@constructor::new#element
+              typeName: A
+              typeNameOffset: 18
+      topLevelVariables
+        hasInitializer a @34
+          reference: <testLibraryFragment>::@topLevelVariable::a
+          element: <testLibrary>::@topLevelVariable::a
+          initializer: expression_0
+            DotShorthandConstructorInvocation
+              period: . @38
+              constructorName: SimpleIdentifier
+                token: new @39
+                element: <testLibraryFragment>::@class::A::@constructor::new#element
+                staticType: null
+              argumentList: ArgumentList
+                leftParenthesis: ( @42
+                rightParenthesis: ) @43
+              staticType: A
+          getter2: <testLibraryFragment>::@getter::a
+      getters
+        synthetic get a
+          reference: <testLibraryFragment>::@getter::a
+          element: <testLibraryFragment>::@getter::a#element
+  classes
+    class A
+      reference: <testLibrary>::@class::A
+      firstFragment: <testLibraryFragment>::@class::A
+      constructors
+        const new
+          firstFragment: <testLibraryFragment>::@class::A::@constructor::new
+  topLevelVariables
+    const hasInitializer a
+      reference: <testLibrary>::@topLevelVariable::a
+      firstFragment: <testLibraryFragment>::@topLevelVariable::a
+      type: A
+      constantInitializer
+        fragment: <testLibraryFragment>::@topLevelVariable::a
+        expression: expression_0
+      getter: <testLibraryFragment>::@getter::a#element
+  getters
+    synthetic static get a
+      firstFragment: <testLibraryFragment>::@getter::a
+      returnType: A
+''');
+  }
+
   test_const_dotShorthand_property() async {
     var library = await buildLibrary(r'''
 class A {