Support constructor references, function references, and type literals as potentially constant

Fixes #47153

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

Author: srawlins

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

@@ -94,7 +94,7 @@ class _Collector {
     }
 
     if (node is TypedLiteral) {
-      return _typeLiteral(node);
+      return _typedLiteral(node);
     }
 
     if (node is ParenthesizedExpression) {
@@ -187,6 +187,22 @@ class _Collector {
       return;
     }
 
+    if (node is ConstructorReference) {
+      _typeArgumentList(node.constructorName.type2.typeArguments);
+      return;
+    }
+
+    if (node is FunctionReference) {
+      _typeArgumentList(node.typeArguments);
+      collect(node.function);
+      return;
+    }
+
+    if (node is TypeLiteral) {
+      _typeArgumentList(node.type.typeArguments);
+      return;
+    }
+
     nodes.add(node);
   }
 
@@ -261,6 +277,7 @@ class _Collector {
         return;
       }
     }
+    // TODO(srawlins): collect type arguments.
     nodes.add(node);
   }
 
@@ -292,7 +309,18 @@ class _Collector {
     nodes.add(node);
   }
 
-  void _typeLiteral(TypedLiteral node) {
+  void _typeArgumentList(TypeArgumentList? typeArgumentList) {
+    var typeArguments = typeArgumentList?.arguments;
+    if (typeArguments != null) {
+      for (var typeArgument in typeArguments) {
+        if (!isPotentiallyConstantTypeExpression(typeArgument)) {
+          nodes.add(typeArgument);
+        }
+      }
+    }
+  }
+
+  void _typedLiteral(TypedLiteral node) {
     if (!node.isConst) {
       nodes.add(node);
       return;
@@ -302,6 +330,8 @@ class _Collector {
       var typeArguments = node.typeArguments?.arguments;
       if (typeArguments != null && typeArguments.length == 1) {
         var elementType = typeArguments[0];
+        // TODO(srawlins): Change to "potentially" constant type expression as
+        // per https://github.com/dart-lang/sdk/issues/47302?
         if (!isConstantTypeExpression(elementType)) {
           nodes.add(elementType);
         }
@@ -317,6 +347,8 @@ class _Collector {
       var typeArguments = node.typeArguments?.arguments;
       if (typeArguments != null && typeArguments.length == 1) {
         var elementType = typeArguments[0];
+        // TODO(srawlins): Change to "potentially" constant type expression as
+        // per https://github.com/dart-lang/sdk/issues/47302?
         if (!isConstantTypeExpression(elementType)) {
           nodes.add(elementType);
         }
@@ -350,7 +382,7 @@ class _ConstantTypeChecker {
 
   _ConstantTypeChecker({required this.potentially});
 
-  /// Return `true` if the [node] is a constant type expression.
+  /// Return `true` if the [node] is a (potentially) constant type expression.
   bool check(TypeAnnotation? node) {
     if (potentially) {
       if (node is NamedType) {

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

@@ -458,6 +458,50 @@ var x = a ? b : c;
             ]);
   }
 
+  test_constructorReference_explicitTypeArguments() async {
+    await _assertConst('''
+class A {
+  final B Function() x;
+  const A(): x = B<int>.new;
+}
+
+class B<T> {}
+''', () => findNode.constructorReference('B<int>.new'));
+  }
+
+  test_constructorReference_noTypeArguments() async {
+    await _assertConst('''
+class A {
+  final B Function() x;
+  const A(): x = B.new;
+}
+
+class B {}
+''', () => findNode.constructorReference('B.new'));
+  }
+
+  test_functionReference_explicitTypeArguments() async {
+    await _assertConst('''
+class A {
+  final int Function(int) x;
+  const A(): x = id<int>;
+}
+
+X id<X>(X x) => x;
+''', () => findNode.functionReference('id<int>'));
+  }
+
+  test_functionReference_noTypeArguments() async {
+    await _assertConst('''
+class A {
+  final int Function(int) x;
+  const A(): x = id;
+}
+
+X id<X>(X x) => x;
+''', () => findNode.simple('id;'));
+  }
+
   test_ifElement_then() async {
     await _assertConst(r'''
 const a = 0;
@@ -1177,6 +1221,15 @@ var x = 'a';
 ''', () => _xInitializer());
   }
 
+  test_typeLiteral() async {
+    await _assertConst('''
+class A {
+  Type x;
+  const A(): x = List<int>;
+}
+''', () => findNode.typeLiteral('List<int>'));
+  }
+
   _assertConst(String code, AstNode Function() getNode) async {
     await resolveTestCode(code);
     var node = getNode();