[analyzer] Dot shorthands: Report error when type arguments are not assignable.

This is a bug fix of the current implementation of dot shorthands type argument resolution. We want to make sure we're doing inference with the proper context type given at that point (with the element based on the dot shorthand context type we've saved).

Then I made sure there was proper argument checking, not just for `FunctionExpressionInvocation`s, but with `DotShorthandInvocation`s as well.

Tested with unit tests and language tests.

Bug: #59835
Change-Id: I795046502214628389c6471e9424aca7152657e2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/425780
Reviewed-by: Chloe Stefantsova <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

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

@@ -258,23 +258,26 @@ class MethodInvocationResolver with ScopeHelpers {
   /// node. Otherwise, returns `null`.
   RewrittenMethodInvocationImpl? resolveDotShorthand(
     DotShorthandInvocationImpl node,
-    List<WhyNotPromotedGetter> whyNotPromotedArguments,
-  ) {
+    List<WhyNotPromotedGetter> whyNotPromotedArguments, {
+    required TypeImpl contextType,
+  }) {
     _invocation = node;
 
-    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): Dot shorthands work - Support other context types
-    if (contextType is InterfaceTypeImpl) {
-      var contextElement = contextType.element3;
+    if (dotShorthandContextType is InterfaceTypeImpl) {
+      var receiver = dotShorthandContextType.element3;
       return _resolveReceiverTypeLiteralForDotShorthand(
         node,
-        contextElement,
+        receiver,
         node.memberName,
         node.memberName.name,
         whyNotPromotedArguments,

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

@@ -193,6 +193,7 @@ class ElementResolver {
     return _methodInvocationResolver.resolveDotShorthand(
       node,
       whyNotPromotedArguments,
+      contextType: contextType,
     );
   }
 

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

@@ -2467,24 +2467,26 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
           whyNotPromotedArguments,
           contextType: contextType,
         );
-
-        var replacement = insertGenericFunctionInstantiation(
-          node,
-          contextType: contextType,
-        );
-        checkForArgumentTypesNotAssignableInList(
-          node.argumentList,
-          whyNotPromotedArguments,
-        );
-        _insertImplicitCallReference(replacement, contextType: contextType);
-
       case DotShorthandConstructorInvocationImpl():
         _instanceCreationExpressionResolver.resolveDotShorthand(
           rewrittenExpression,
           contextType: contextType,
         );
     }
 
+    if (rewrittenExpression is FunctionExpressionInvocationImpl ||
+        rewrittenExpression == null) {
+      var replacement = insertGenericFunctionInstantiation(
+        node,
+        contextType: contextType,
+      );
+      checkForArgumentTypesNotAssignableInList(
+        node.argumentList,
+        whyNotPromotedArguments,
+      );
+      _insertImplicitCallReference(replacement, contextType: contextType);
+    }
+
     if (isDotShorthand(node)) {
       popDotShorthandContext();
     }

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

@@ -618,4 +618,57 @@ DotShorthandInvocation
     dynamic
 ''');
   }
+
+  test_typeParameters_inference() async {
+    await assertNoErrorsInCode(r'''
+class C<T> {
+  static C<X> foo<X>(X x) => new C<X>();
+  C<U> cast<U>() => new C<U>();
+}
+void main() {
+  C<bool> c = .foo("String").cast();
+  print(c);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandInvocation;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandInvocation
+  period: .
+  memberName: SimpleIdentifier
+    token: foo
+    element: <testLibraryFragment>::@class::C::@method::foo#element
+    staticType: C<X> Function<X>(X)
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: "String"
+    rightParenthesis: )
+  staticInvokeType: C<String> Function(String)
+  staticType: C<String>
+  typeArgumentTypes
+    String
+''');
+  }
+
+  test_typeParameters_notAssignable() async {
+    await assertErrorsInCode(
+      r'''
+class C<T> {
+  static C<int> member() => C(1);
+
+  final T t;
+  C(this.t);
+}
+
+void main() {
+  C<bool> c = .member();
+  print(c);
+}
+
+''',
+      [error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 105, 9)],
+    );
+  }
 }

tests/language/dot_shorthands/member/static_method_type_parameter_error_test.dart

@@ -11,22 +11,22 @@ import '../dot_shorthand_helper.dart';
 
 void main() {
   StaticMember<bool> s = .member();
-  // ^
-  // [analyzer] unspecified
-  // [cfe] unspecified
+  //                     ^^^^^^^^^
+  // [analyzer] COMPILE_TIME_ERROR.INVALID_ASSIGNMENT
+  // [cfe] A value of type 'StaticMember<int>' can't be assigned to a variable of type 'StaticMember<bool>'.
 
   StaticMember<int> sTypeParameters = .memberType("s");
-  // ^
-  // [analyzer] unspecified
-  // [cfe] unspecified
+  //                                              ^^^
+  // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
+  // [cfe] The argument type 'String' can't be assigned to the parameter type 'int'.
 
   StaticMemberExt<bool> sExt = .member();
-  // ^
-  // [analyzer] unspecified
-  // [cfe] unspecified
+  //                           ^^^^^^^^^
+  // [analyzer] COMPILE_TIME_ERROR.INVALID_ASSIGNMENT
+  // [cfe] A value of type 'StaticMemberExt<int>' can't be assigned to a variable of type 'StaticMemberExt<bool>'.
 
   StaticMemberExt<int> sTypeParametersExt = .memberType("s");
-  // ^
-  // [analyzer] unspecified
-  // [cfe] unspecified
+  //                                                    ^^^
+  // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
+  // [cfe] The argument type 'String' can't be assigned to the parameter type 'int'.
 }