Support Never as a type in potentially const expressions

Additionally, I see that _deferred types_ are not constant, and make
great examples of non-const function references, constructor references,
and type literals.

Fixes language/const/constant_type_variable_test

Bug: #46020,
     #47302
Change-Id: I9df3a9eb758d058888f7d374b76756ec1443c8d6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/215860
Commit-Queue: Samuel Rawlins <srawlins@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>

Author: srawlins

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

@@ -330,9 +330,7 @@ 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)) {
+        if (!isPotentiallyConstantTypeExpression(elementType)) {
           nodes.add(elementType);
         }
       }
@@ -347,9 +345,7 @@ 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)) {
+        if (!isPotentiallyConstantTypeExpression(elementType)) {
           nodes.add(elementType);
         }
       }
@@ -406,10 +402,8 @@ class _ConstantTypeChecker {
         }
         return true;
       }
-      if (node.type is DynamicTypeImpl) {
-        return true;
-      }
-      if (node.type is VoidType) {
+      var type = node.type;
+      if (type is DynamicTypeImpl || type is NeverType || type is VoidType) {
         return true;
       }
       return false;

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

@@ -469,6 +469,19 @@ class B<T> {}
 ''', () => findNode.constructorReference('B<int>.new'));
   }
 
+  test_constructorReference_explicitTypeArguments_nonConst() async {
+    await _assertNotConst('''
+import '' deferred as self;
+class A {
+  Object x;
+  const A(): x = B<self.A>.new;
+}
+
+class B<T> {}
+''', () => findNode.constructorReference('B<self.A>.new'),
+        () => [findNode.typeAnnotation('self.A')]);
+  }
+
   test_constructorReference_noTypeArguments() async {
     await _assertConst('''
 class A {
@@ -491,6 +504,19 @@ X id<X>(X x) => x;
 ''', () => findNode.functionReference('id<int>'));
   }
 
+  test_functionReference_explicitTypeArguments_nonConst() async {
+    await _assertNotConst('''
+import '' deferred as self;
+class A {
+  final int Function(int) x;
+  const A(): x = id<self.A>;
+}
+
+X id<X>(X x) => x;
+''', () => findNode.functionReference('id<self.A>'),
+        () => [findNode.typeAnnotation('self.A')]);
+  }
+
   test_functionReference_noTypeArguments() async {
     await _assertConst('''
 class A {
@@ -617,20 +643,39 @@ var x = const [a, b, 2];
         () => [findNode.simple('a,'), findNode.simple('b,')]);
   }
 
+  test_listLiteral_ofDynamic() async {
+    await _assertConst('''
+var x = const <dynamic>[];
+''', () => _xInitializer());
+  }
+
+  test_listLiteral_ofNever() async {
+    await _assertConst('''
+var x = const <Never>[];
+''', () => _xInitializer());
+  }
+
+  test_listLiteral_ofVoid() async {
+    await _assertConst('''
+var x = const <void>[];
+''', () => _xInitializer());
+  }
+
   test_listLiteral_typeArgument() async {
     await _assertConst(r'''
 var x = const <int>[0, 1, 2];
 ''', () => _xInitializer());
   }
 
   test_listLiteral_typeArgument_notConstType() async {
-    await _assertNotConst(r'''
-class A<T> {
+    await _assertNotConst('''
+import '' deferred as self;
+class A {
   m() {
-    var x = const <T>[0, 1, 2];
+    var x = const <self.A>[];
   }
 }
-''', () => _xInitializer(), () => [findNode.namedType('T>[0')]);
+''', () => _xInitializer(), () => [findNode.namedType('A>[')]);
   }
 
   test_literal_bool() async {
@@ -1039,13 +1084,14 @@ var x = const <int>{0, 1, 2};
   }
 
   test_setLiteral_typeArgument_notConstType() async {
-    await _assertNotConst(r'''
-class A<T> {
+    await _assertNotConst('''
+import '' deferred as self;
+class A {
   m() {
-    var x = const <T>{0, 1, 2};
+    var x = const <self.A>{};
   }
 }
-''', () => _xInitializer(), () => [findNode.namedType('T>{0')]);
+''', () => _xInitializer(), () => [findNode.namedType('A>{')]);
   }
 
   test_simpleIdentifier_class() async {
@@ -1230,6 +1276,17 @@ class A {
 ''', () => findNode.typeLiteral('List<int>'));
   }
 
+  test_typeLiteral_nonConst() async {
+    await _assertNotConst('''
+import '' deferred as self;
+class A {
+  Type x;
+  const A(): x = List<self.A>;
+}
+''', () => findNode.typeLiteral('List<self.A>'),
+        () => [findNode.typeAnnotation('self.A')]);
+  }
+
   _assertConst(String code, AstNode Function() getNode) async {
     await resolveTestCode(code);
     var node = getNode();