[analyzer] Dot Shorthands: Pipe RHS == context to dot shorthand.

When there's exactly a dot shorthand of the RHS of `==`, we use the namespace of the LHS to resolve the shorthand on the RHS.

There's existing CFE work done for the `case ==` case in the type analyzer, so we just have to make sure `isDotShorthand` is properly set. This will take care of the relational pattern `==` behaviour.

Tested using language tests and resolution unit tests.

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

Author: kallentu

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -271,8 +271,12 @@ mixin TypeAnalyzer<
         TypeDeclarationType extends Object,
         TypeDeclaration extends Object>
     implements TypeAnalysisNullShortingInterface<Expression, SharedTypeView> {
-  /// Cached context types used to resolve dot shorthand heads.
-  final _dotShorthands = <SharedTypeSchemaView>[];
+  /// Cached context types and their respective dot shorthand nodes.
+  ///
+  /// The [SharedTypeSchemaView] is used to resolve dot shorthand heads. We
+  /// save the corresponding dot shorthand [Node] to make sure we aren't caching
+  /// two context types for the same node.
+  final _dotShorthands = <(Node, SharedTypeSchemaView)>[];
 
   TypeAnalyzerErrors<Node, Statement, Expression, Variable, SharedTypeView,
       Pattern, Error> get errors;
@@ -538,10 +542,10 @@ mixin TypeAnalyzer<
   /// Saves the [context] for when we resolve the dot shorthand head.
   SharedTypeView analyzeDotShorthand(
       Expression node, SharedTypeSchemaView context) {
-    _dotShorthands.add(context);
+    pushDotShorthandContext(node, context);
     ExpressionTypeAnalysisResult analysisResult =
         dispatchExpression(node, context);
-    _dotShorthands.removeLast();
+    popDotShorthandContext();
     return analysisResult.type;
   }
 
@@ -2167,7 +2171,7 @@ mixin TypeAnalyzer<
   });
 
   /// Returns the most recently cached dot shorthand context type.
-  SharedTypeSchemaView getDotShorthandContext() => _dotShorthands.last;
+  SharedTypeSchemaView getDotShorthandContext() => _dotShorthands.last.$2;
 
   /// If the [element] is a map pattern entry, returns it.
   MapPatternEntry<Expression, Pattern>? getMapPatternEntry(Node element);
@@ -2355,10 +2359,12 @@ mixin TypeAnalyzer<
     _dotShorthands.removeLast();
   }
 
-  /// Pushes the [context] onto the stack to use when we resolve the dot
-  /// shorthand head.
-  void pushDotShorthandContext(SharedTypeSchemaView context) {
-    _dotShorthands.add(context);
+  /// Pushes the [node] and [context] onto the stack to use when we resolve the
+  /// dot shorthand head.
+  void pushDotShorthandContext(Node node, SharedTypeSchemaView context) {
+    if (_dotShorthands.isEmpty || _dotShorthands.last.$1 != node) {
+      _dotShorthands.add((node, context));
+    }
   }
 
   /// Returns the type of the property in [receiverType] that corresponds to

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

@@ -106,6 +106,15 @@ class BinaryExpressionResolver {
       leftInfo = flow?.equalityOperand_end(left);
     }
 
+    // When evaluating exactly a dot shorthand in the RHS, we save the LHS type
+    // to provide the context type for the shorthand.
+    if (node.rightOperand is DotShorthandMixin) {
+      _resolver.pushDotShorthandContext(
+        node.rightOperand,
+        SharedTypeSchemaView(left.typeOrThrow),
+      );
+    }
+
     _resolver.analyzeExpression(
       node.rightOperand,
       SharedTypeSchemaView(UnknownInferredType.instance),

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

@@ -56,17 +56,26 @@ class InstanceCreationExpressionResolver {
   }
 
   /// Resolves a [DotShorthandConstructorInvocation] node.
-  void resolveDotShorthand(DotShorthandConstructorInvocationImpl node) {
-    TypeImpl contextType =
+  void resolveDotShorthand(
+    DotShorthandConstructorInvocationImpl node, {
+    required TypeImpl contextType,
+  }) {
+    TypeImpl dotShorthandContextType =
         _resolver.getDotShorthandContext().unwrapTypeSchemaView();
 
     // The static namespace denoted by `S` is also the namespace denoted by
     // `FutureOr<S>`.
-    contextType = _resolver.typeSystem.futureOrBase(contextType);
+    dotShorthandContextType = _resolver.typeSystem.futureOrBase(
+      dotShorthandContextType,
+    );
 
     // TODO(kallentu): Support other context types
-    if (contextType is InterfaceTypeImpl) {
-      _resolveDotShorthandConstructorInvocation(node, contextType: contextType);
+    if (dotShorthandContextType is InterfaceTypeImpl) {
+      _resolveDotShorthandConstructorInvocation(
+        node,
+        contextType: contextType,
+        dotShorthandContextType: dotShorthandContextType,
+      );
     }
 
     // TODO(kallentu): Report error.
@@ -75,15 +84,16 @@ class InstanceCreationExpressionResolver {
   void _resolveDotShorthandConstructorInvocation(
     DotShorthandConstructorInvocationImpl node, {
     required TypeImpl contextType,
+    required TypeImpl dotShorthandContextType,
   }) {
     var whyNotPromotedArguments = <WhyNotPromotedGetter>[];
     _resolver.elementResolver.visitDotShorthandConstructorInvocation(node);
     var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
-      typeElement: contextType.element3,
+      typeElement: dotShorthandContextType.element3,
       constructorName: node.constructorName,
       definingLibrary: _resolver.definingLibrary,
     );
-    DotShorthandConstructorInvocationInferrer(
+    var returnType = DotShorthandConstructorInvocationInferrer(
       resolver: _resolver,
       node: node,
       argumentList: node.argumentList,
@@ -94,7 +104,7 @@ class InstanceCreationExpressionResolver {
       // `ConstructorElementToInfer.asType`.
       rawType: elementToInfer?.asType as FunctionTypeImpl?,
     );
-    node.recordStaticType(contextType, resolver: _resolver);
+    node.recordStaticType(returnType, resolver: _resolver);
     _resolver.checkForArgumentTypesNotAssignableInList(
       node.argumentList,
       whyNotPromotedArguments,

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

@@ -1240,7 +1240,9 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
 
   @override
   bool isDotShorthand(ExpressionImpl node) {
-    // TODO(kallentu): Implement this for dot shorthand equality implementation.
+    if (node is DotShorthandMixin) {
+      return (node as DotShorthandMixin).isDotShorthand;
+    }
     return false;
   }
 
@@ -2416,8 +2418,8 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     inferenceLogWriter?.enterExpression(node, contextType);
 
     // If [isDotShorthand] is set, cache the context type for resolution.
-    if (node.isDotShorthand) {
-      pushDotShorthandContext(SharedTypeSchemaView(contextType));
+    if (isDotShorthand(node)) {
+      pushDotShorthandContext(node, SharedTypeSchemaView(contextType));
     }
 
     checkUnreachableNode(node);
@@ -2454,10 +2456,11 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
       case DotShorthandConstructorInvocationImpl():
         _instanceCreationExpressionResolver.resolveDotShorthand(
           rewrittenExpression,
+          contextType: contextType,
         );
     }
 
-    if (node.isDotShorthand) {
+    if (isDotShorthand(node)) {
       popDotShorthandContext();
     }
 
@@ -2472,8 +2475,8 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     inferenceLogWriter?.enterExpression(node, contextType);
 
     // If [isDotShorthand] is set, cache the context type for resolution.
-    if (node.isDotShorthand) {
-      pushDotShorthandContext(SharedTypeSchemaView(contextType));
+    if (isDotShorthand(node)) {
+      pushDotShorthandContext(node, SharedTypeSchemaView(contextType));
     }
 
     checkUnreachableNode(node);
@@ -2485,7 +2488,7 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
       contextType,
     );
 
-    if (node.isDotShorthand) {
+    if (isDotShorthand(node)) {
       popDotShorthandContext();
     }
 

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

@@ -85,7 +85,205 @@ DotShorthandConstructorInvocation
           substitution: {T: dynamic}
         staticType: int
     rightParenthesis: )
-  staticType: C<dynamic>?
+  staticType: C<dynamic>
+''');
+  }
+
+  test_equality() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  int x;
+  C.named(this.x);
+}
+
+void main() {
+  C lhs = C.named(2);
+  bool b = lhs == .named(1);
+  print(b);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandConstructorInvocation
+  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_equality_inferTypeParameters() async {
+    await assertNoErrorsInCode('''
+void main() {
+  bool x = <int>[] == .filled(2, '2');
+  print(x);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandConstructorInvocation
+  period: .
+  constructorName: SimpleIdentifier
+    token: filled
+    element: ConstructorMember
+      baseElement: dart:core::<fragment>::@class::List::@constructor::filled#element
+      substitution: {E: String}
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      IntegerLiteral
+        literal: 2
+        correspondingParameter: ParameterMember
+          baseElement: dart:core::<fragment>::@class::List::@constructor::filled::@parameter::length#element
+          substitution: {E: String}
+        staticType: int
+      SimpleStringLiteral
+        literal: '2'
+    rightParenthesis: )
+  correspondingParameter: dart:core::<fragment>::@class::Object::@method::==::@parameter::other#element
+  staticType: List<String>
+''');
+  }
+
+  @FailingTest(
+    issue: 'https://github.com/dart-lang/sdk/issues/59835',
+    reason:
+        'Constant evaluation for dot shorthand constructor invocations needs '
+        'to be implemented.',
+  )
+  test_equality_pattern() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  int x;
+  C.named(this.x);
+}
+
+void main() {
+  C c = C.named(1);
+  if (c case == .named(2)) print('ok');
+}
+''');
+
+    var identifier = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandConstructorInvocation
+  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_nested_invocation() async {
+    await assertNoErrorsInCode(r'''
+class C<T> {
+  static C member() => C(1);
+  T x;
+  C(this.x);
+}
+
+void main() {
+  C<C> c = .new(.member());
+  print(c);
+}
+''');
+
+    var node = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(node, r'''
+DotShorthandConstructorInvocation
+  period: .
+  constructorName: SimpleIdentifier
+    token: new
+    element: ConstructorMember
+      baseElement: <testLibraryFragment>::@class::C::@constructor::new#element
+      substitution: {T: C<dynamic>}
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      DotShorthandInvocation
+        period: .
+        memberName: SimpleIdentifier
+          token: member
+          element: <testLibraryFragment>::@class::C::@method::member#element
+          staticType: C<dynamic> Function()
+        argumentList: ArgumentList
+          leftParenthesis: (
+          rightParenthesis: )
+        correspondingParameter: FieldFormalParameterMember
+          baseElement: <testLibraryFragment>::@class::C::@constructor::new::@parameter::x#element
+          substitution: {T: C<dynamic>}
+        staticInvokeType: C<dynamic> Function()
+        staticType: C<dynamic>
+    rightParenthesis: )
+  staticType: C<C<dynamic>>
+''');
+  }
+
+  test_nested_property() async {
+    await assertNoErrorsInCode(r'''
+class C<T> {
+  static C get member => C(1);
+  T x;
+  C(this.x);
+}
+
+void main() {
+  C<C> c = .new(.member);
+  print(c);
+}
+''');
+
+    var node = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(node, r'''
+DotShorthandConstructorInvocation
+  period: .
+  constructorName: SimpleIdentifier
+    token: new
+    element: ConstructorMember
+      baseElement: <testLibraryFragment>::@class::C::@constructor::new#element
+      substitution: {T: C<dynamic>}
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      DotShorthandPropertyAccess
+        period: .
+        propertyName: SimpleIdentifier
+          token: member
+          element: <testLibraryFragment>::@class::C::@getter::member#element
+          staticType: C<dynamic>
+        correspondingParameter: FieldFormalParameterMember
+          baseElement: <testLibraryFragment>::@class::C::@constructor::new::@parameter::x#element
+          substitution: {T: C<dynamic>}
+        staticType: C<dynamic>
+    rightParenthesis: )
+  staticType: C<C<dynamic>>
 ''');
   }