Support const implicit instantiation for prefixed identifiers and property access

Bug: #46020
Change-Id: I99bfa6d96b84a41abdd02d41ff6ad7dd5c99789c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/215687
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

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

@@ -867,8 +867,8 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
         return null;
       }
     }
-    // validate prefixed identifier
-    return _getConstantValue(node, node.staticElement);
+    // Validate prefixed identifier.
+    return _getConstantValue(node, node.identifier);
   }
 
   @override
@@ -902,7 +902,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
         return prefixResult.stringLength(typeSystem);
       }
     }
-    return _getConstantValue(node, node.propertyName.staticElement);
+    return _getConstantValue(node, node.propertyName);
   }
 
   @override
@@ -971,7 +971,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
       return _instantiateFunctionType(node, value);
     }
 
-    return _getConstantValue(node, node.staticElement);
+    return _getConstantValue(node, node);
   }
 
   @override
@@ -1171,9 +1171,11 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
   }
 
   /// Return the constant value of the static constant represented by the given
-  /// [element]. The [node] is the node to be used if an error needs to be
+  /// [identifier]. The [node] is the node to be used if an error needs to be
   /// reported.
-  DartObjectImpl? _getConstantValue(Expression node, Element? element) {
+  DartObjectImpl? _getConstantValue(
+      Expression node, SimpleIdentifier identifier) {
+    var element = identifier.staticElement;
     element = element?.declaration;
     var variableElement =
         element is PropertyAccessorElement ? element.variable : element;
@@ -1196,7 +1198,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
         if (value == null) {
           return value;
         }
-        return _instantiateFunctionType(node, value);
+        return _instantiateFunctionType(identifier, value);
       }
     } else if (variableElement is ConstructorElement) {
       return DartObjectImpl(
@@ -1207,11 +1209,12 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
     } else if (variableElement is ExecutableElement) {
       var function = element as ExecutableElement;
       if (function.isStatic) {
-        return DartObjectImpl(
+        var rawType = DartObjectImpl(
           typeSystem,
-          node.typeOrThrow,
+          function.type,
           FunctionState(function),
         );
+        return _instantiateFunctionType(identifier, rawType);
       }
     } else if (variableElement is ClassElement) {
       var type = variableElement.instantiate(
@@ -1264,10 +1267,7 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
   /// type-instantiated with those [node]'s tear-off type argument types,
   /// otherwise returns [value].
   DartObjectImpl? _instantiateFunctionType(
-      Expression node, DartObjectImpl value) {
-    if (node is! SimpleIdentifier) {
-      return value;
-    }
+      SimpleIdentifier node, DartObjectImpl value) {
     var functionElement = value.toFunctionValue();
     if (functionElement is! ExecutableElement) {
       return value;

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

@@ -566,7 +566,48 @@ const void Function(int) g = self.f;
     var result = _evaluateConstant('g');
     assertType(result.type, 'void Function(int)');
     assertElement(result.toFunctionValue(), findElement.topFunction('f'));
-    _assertTypeArguments(result, null);
+    _assertTypeArguments(result, ['int']);
+  }
+
+  test_visitPrefixedIdentifier_genericFunction_instantiatedNonIdentifier() async {
+    await resolveTestCode('''
+void f<T>(T a) {}
+const b = false;
+const g1 = f;
+const g2 = f;
+const void Function(int) h = b ? g1 : g2;
+''');
+    var result = _evaluateConstant('h');
+    assertType(result.type, 'void Function(int)');
+    assertElement(result.toFunctionValue(), findElement.topFunction('f'));
+    _assertTypeArguments(result, ['int']);
+  }
+
+  test_visitPrefixedIdentifier_genericFunction_instantiatedPrefixed() async {
+    await resolveTestCode('''
+import '' as self;
+void f<T>(T a) {}
+const g = f;
+const void Function(int) h = self.g;
+''');
+    var result = _evaluateConstant('h');
+    assertType(result.type, 'void Function(int)');
+    assertElement(result.toFunctionValue(), findElement.topFunction('f'));
+    _assertTypeArguments(result, ['int']);
+  }
+
+  test_visitPropertyAccess_genericFunction_instantiated() async {
+    await resolveTestCode('''
+import '' as self;
+class C {
+  static void f<T>(T a) {}
+}
+const void Function(int) g = self.C.f;
+''');
+    var result = _evaluateConstant('g');
+    assertType(result.type, 'void Function(int)');
+    assertElement(result.toFunctionValue(), findElement.method('f'));
+    _assertTypeArguments(result, ['int']);
   }
 
   test_visitSimpleIdentifier_className() async {
@@ -583,6 +624,17 @@ class C {}
     await resolveTestCode('''
 void f<T>(T a) {}
 const void Function(int) g = f;
+''');
+    var result = _evaluateConstant('g');
+    assertType(result.type, 'void Function(int)');
+    assertElement(result.toFunctionValue(), findElement.topFunction('f'));
+    _assertTypeArguments(result, ['int']);
+  }
+
+  test_visitSimpleIdentifier_genericFunction_nonGeneric() async {
+    await resolveTestCode('''
+void f(int a) {}
+const void Function(int) g = f;
 ''');
     var result = _evaluateConstant('g');
     assertType(result.type, 'void Function(int)');