[cfe] Handle potentially constant types in instantiations

Part of #46232

Closes #47154

Change-Id: I71fe16d26facf29bdae1b98971c4ccfe18f95e80
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/213772
Reviewed-by: Chloe Stefantsova <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart

@@ -69,6 +69,7 @@ enum NullValue {
   TypeList,
   TypeVariable,
   TypeVariables,
+  UnresolvedType,
   VarFinalOrConstToken,
   WithClause,
 }
@@ -374,7 +375,7 @@ abstract class StackListener extends Listener {
   @override
   void handleNoType(Token lastConsumed) {
     debugEvent("NoType");
-    push(NullValue.Type);
+    push(NullValue.UnresolvedType);
   }
 
   @override

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

@@ -260,7 +260,9 @@ abstract class Generator {
   Expression_Generator applyTypeArguments(
       int fileOffset, List<UnresolvedType>? typeArguments) {
     return new Instantiation(
-        buildSimpleRead(), _helper.buildDartTypeArguments(typeArguments))
+        buildSimpleRead(),
+        _helper.buildDartTypeArguments(typeArguments,
+            allowPotentiallyConstantType: true))
       ..fileOffset = fileOffset;
   }
 
@@ -270,7 +272,8 @@ abstract class Generator {
   /// The type arguments have not been resolved and should be resolved to
   /// create a [TypeBuilder] for a valid type.
   TypeBuilder buildTypeWithResolvedArguments(
-      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments) {
+      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments,
+      {required bool allowPotentiallyConstantType}) {
     // TODO(johnniwinther): Could we use a FixedTypeBuilder(InvalidType()) here?
     NamedTypeBuilder result = new NamedTypeBuilder(
         token.lexeme,
@@ -2897,11 +2900,13 @@ class DeferredAccessGenerator extends Generator {
 
   @override
   TypeBuilder buildTypeWithResolvedArguments(
-      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments) {
+      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments,
+      {required bool allowPotentiallyConstantType}) {
     String name = "${prefixGenerator._plainNameForRead}."
         "${suffixGenerator._plainNameForRead}";
     TypeBuilder type = suffixGenerator.buildTypeWithResolvedArguments(
-        nullabilityBuilder, arguments);
+        nullabilityBuilder, arguments,
+        allowPotentiallyConstantType: allowPotentiallyConstantType);
     LocatedMessage message;
     if (type is NamedTypeBuilder &&
         type.declaration is InvalidTypeDeclarationBuilder) {
@@ -2912,7 +2917,8 @@ class DeferredAccessGenerator extends Generator {
       int charOffset = offsetForToken(prefixGenerator.token);
       message = templateDeferredTypeAnnotation
           .withArguments(
-              _helper.buildDartType(new UnresolvedType(type, charOffset, _uri)),
+              _helper.buildDartType(new UnresolvedType(type, charOffset, _uri),
+                  allowPotentiallyConstantType: allowPotentiallyConstantType),
               prefixGenerator._plainNameForRead,
               _helper.libraryBuilder.isNonNullableByDefault)
           .withLocation(
@@ -3022,17 +3028,19 @@ class TypeUseGenerator extends AbstractReadOnlyAccessGenerator {
 
   @override
   TypeBuilder buildTypeWithResolvedArguments(
-      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments) {
+      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments,
+      {required bool allowPotentiallyConstantType}) {
     if (declaration.isExtension && !_helper.enableExtensionTypesInLibrary) {
       // Extension declarations cannot be used as types.
-      return super
-          .buildTypeWithResolvedArguments(nullabilityBuilder, arguments);
+      return super.buildTypeWithResolvedArguments(nullabilityBuilder, arguments,
+          allowPotentiallyConstantType: allowPotentiallyConstantType);
     }
     if (arguments != null) {
       int expected = declaration.typeVariablesCount;
       if (arguments.length != expected) {
         // Build the type arguments to report any errors they may have.
-        _helper.buildDartTypeArguments(arguments);
+        _helper.buildDartTypeArguments(arguments,
+            allowPotentiallyConstantType: allowPotentiallyConstantType);
         _helper.warnTypeArgumentsMismatch(
             declaration.name, expected, fileOffset);
         // We ignore the provided arguments, which will in turn return the
@@ -3048,11 +3056,8 @@ class TypeUseGenerator extends AbstractReadOnlyAccessGenerator {
       argumentBuilders =
           new List<TypeBuilder>.generate(arguments.length, (int i) {
         return _helper
-            .validateTypeUse(arguments![i],
-                nonInstanceAccessIsError: false,
-                allowPotentiallyConstantType:
-                    _helper.libraryBuilder.isNonNullableByDefault &&
-                        _helper.inIsOrAsOperatorType)
+            .validateTypeVariableUse(arguments![i],
+                allowPotentiallyConstantType: allowPotentiallyConstantType)
             .builder;
       }, growable: false);
     }
@@ -3105,10 +3110,12 @@ class TypeUseGenerator extends AbstractReadOnlyAccessGenerator {
                 new UnresolvedType(
                     buildTypeWithResolvedArguments(
                         _helper.libraryBuilder.nonNullableBuilder,
-                        typeArguments),
+                        typeArguments,
+                        allowPotentiallyConstantType: true),
                     fileOffset,
                     _uri),
-                nonInstanceAccessIsError: true));
+                allowPotentiallyConstantType:
+                    _helper.enableConstructorTearOffsInLibrary));
       }
     }
     return _expression!;
@@ -3131,8 +3138,16 @@ class TypeUseGenerator extends AbstractReadOnlyAccessGenerator {
           isUsedAsClass: true,
           usedAsClassCharOffset: this.fileOffset,
           usedAsClassFileUri: _uri);
-      List<TypeBuilder>? aliasedTypeArguments =
-          typeArguments?.map((unknownType) => unknownType.builder).toList();
+
+      bool isConstructorTearOff = send is PropertySelector &&
+          _helper.enableConstructorTearOffsInLibrary &&
+          declarationBuilder is ClassBuilder;
+      List<TypeBuilder>? aliasedTypeArguments = typeArguments
+          ?.map((unknownType) => _helper
+              .validateTypeVariableUse(unknownType,
+                  allowPotentiallyConstantType: isConstructorTearOff)
+              .builder)
+          .toList();
       if (aliasedTypeArguments != null &&
           aliasedTypeArguments.length != aliasBuilder.typeVariablesCount) {
         _helper.libraryBuilder.addProblem(
@@ -3236,8 +3251,9 @@ class TypeUseGenerator extends AbstractReadOnlyAccessGenerator {
                       _helper.libraryBuilder, unaliasedTypeArguments);
                 }
               } else if (typeArguments != null) {
-                builtTypeArguments =
-                    _helper.buildDartTypeArguments(typeArguments);
+                builtTypeArguments = _helper.buildDartTypeArguments(
+                    typeArguments,
+                    allowPotentiallyConstantType: true);
               }
               if (isGenericTypedefTearOff) {
                 if (isProperRenameForClass(_helper.typeEnvironment,
@@ -3670,7 +3686,9 @@ abstract class ErroneousExpressionGenerator extends Generator {
     if (typeArguments != null) {
       assert(_forest.argumentsTypeArguments(arguments).isEmpty);
       _forest.argumentsSetTypeArguments(
-          arguments, _helper.buildDartTypeArguments(typeArguments));
+          arguments,
+          _helper.buildDartTypeArguments(typeArguments,
+              allowPotentiallyConstantType: false));
     }
     return buildError(arguments, kind: UnresolvedKind.Constructor);
   }
@@ -4145,7 +4163,8 @@ class UnexpectedQualifiedUseGenerator extends Generator {
 
   @override
   TypeBuilder buildTypeWithResolvedArguments(
-      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments) {
+      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments,
+      {required bool allowPotentiallyConstantType}) {
     Template<Message Function(String, String)> template = isUnresolved
         ? templateUnresolvedPrefixInTypeAnnotation
         : templateNotAPrefixInTypeAnnotation;
@@ -4269,7 +4288,8 @@ class ParserErrorGenerator extends Generator {
 
   @override
   TypeBuilder buildTypeWithResolvedArguments(
-      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments) {
+      NullabilityBuilder nullabilityBuilder, List<UnresolvedType>? arguments,
+      {required bool allowPotentiallyConstantType}) {
     // TODO(johnniwinther): Could we use a FixedTypeBuilder(InvalidType()) here?
     NamedTypeBuilder result = new NamedTypeBuilder(
         token.lexeme,

pkg/front_end/lib/src/fasta/kernel/expression_generator.dart

@@ -48,9 +48,6 @@ abstract class ExpressionGeneratorHelper implements InferenceHelper {
 
   Member? lookupInstanceMember(Name name, {bool isSetter, bool isSuper});
 
-  /// `true` if we are in the type of an as expression.
-  bool get inIsOrAsOperatorType;
-
   bool get enableExtensionTypesInLibrary;
 
   bool get enableConstFunctionsInLibrary;
@@ -125,9 +122,8 @@ abstract class ExpressionGeneratorHelper implements InferenceHelper {
       TypeDeclarationBuilder? typeAliasBuilder,
       required UnresolvedKind unresolvedKind});
 
-  UnresolvedType validateTypeUse(UnresolvedType unresolved,
-      {required bool nonInstanceAccessIsError,
-      required bool allowPotentiallyConstantType});
+  UnresolvedType validateTypeVariableUse(UnresolvedType unresolved,
+      {required bool allowPotentiallyConstantType});
 
   void addProblemErrorIfConst(Message message, int charOffset, int length);
 
@@ -150,12 +146,13 @@ abstract class ExpressionGeneratorHelper implements InferenceHelper {
       Arguments arguments, Expression expression);
 
   DartType buildDartType(UnresolvedType unresolvedType,
-      {bool nonInstanceAccessIsError: false});
+      {required bool allowPotentiallyConstantType});
 
   DartType buildTypeLiteralDartType(UnresolvedType unresolvedType,
-      {bool nonInstanceAccessIsError});
+      {required bool allowPotentiallyConstantType});
 
-  List<DartType> buildDartTypeArguments(List<UnresolvedType>? unresolvedTypes);
+  List<DartType> buildDartTypeArguments(List<UnresolvedType>? unresolvedTypes,
+      {required bool allowPotentiallyConstantType});
 
   void reportDuplicatedDeclaration(
       Builder existing, String name, int charOffset);

pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart

@@ -108,15 +108,15 @@ class ValueKinds {
   static const ValueKind TokenOrNull =
       const SingleValueKind<type.Token>(NullValue.Token);
   static const ValueKind TypeOrNull =
-      const SingleValueKind<type.UnresolvedType>(NullValue.Type);
+      const SingleValueKind<type.UnresolvedType>(NullValue.UnresolvedType);
   static const ValueKind TypeArguments =
       const SingleValueKind<List<type.UnresolvedType>>();
   static const ValueKind TypeArgumentsOrNull =
       const SingleValueKind<List<type.UnresolvedType>>(NullValue.TypeArguments);
   static const ValueKind TypeBuilder =
       const SingleValueKind<type.TypeBuilder>();
   static const ValueKind TypeBuilderOrNull =
-      const SingleValueKind<type.TypeBuilder>(NullValue.Type);
+      const SingleValueKind<type.TypeBuilder>(NullValue.UnresolvedType);
   static const ValueKind TypeBuilderListOrNull =
       const SingleValueKind<List<type.TypeBuilder>>(NullValue.TypeBuilderList);
   static const ValueKind TypeVariableListOrNull =

pkg/front_end/lib/src/fasta/source/value_kinds.dart

@@ -935,6 +935,7 @@ prime
 printer
 printf
 println
+prioritization
 proc
 producers
 product

pkg/front_end/test/spell_checking_list_code.txt

@@ -0,0 +1,32 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// A potentially constant type expression is supported for `as` (and `is`)
+class A<X> {
+  final List<X> x;
+  const A(x) : x = x is List<X> ? x : x as List<X>;
+}
+
+void m<X>(X x) {}
+
+// Generic function instantiation to a type parameter is supported implicitly.
+class B<X> {
+  final void Function(X) f;
+  const B() : f = m;
+}
+
+// But it is not supported explicitly.
+class C<X> {
+  final f;
+  const C() : f = m<X>; // Error, but should be accepted.
+}
+
+void main() {
+  const A<int>(<int>[1]); // OK.
+  const b = B<String>(); // OK.
+  print(b.f.runtimeType); // OK: 'String => void'.
+  const c = C<
+      String>(); // Compile-time error in `C`, but should be accepted when it works.
+  print(c.f.runtimeType); // (Never executed, so we don't know).
+}

pkg/front_end/testcases/constructor_tearoffs/issue47154c.dart

@@ -0,0 +1,46 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class A<X extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  final field core::List<self::A::X%> x;
+  const constructor •(dynamic x) → self::A<self::A::X%>
+    : self::A::x = x is{ForNonNullableByDefault} core::List<self::A::X%> ?{core::List<self::A::X%>} x{core::List<self::A::X%>} : x as{ForNonNullableByDefault} core::List<self::A::X%>, super core::Object::•()
+    ;
+}
+class B<X extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  final field (self::B::X%) → void f;
+  const constructor •() → self::B<self::B::X%>
+    : self::B::f = #C1<self::B::X%>, super core::Object::•()
+    ;
+}
+class C<X extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  final field dynamic f;
+  const constructor •() → self::C<self::C::X%>
+    : self::C::f = #C1<self::C::X%>, super core::Object::•()
+    ;
+}
+static method m<X extends core::Object? = dynamic>(self::m::X% x) → void {}
+static method main() → void {
+  #C4;
+  core::print((#C6.{self::B::f}{(core::String) → void} as{TypeError,CovarianceCheck,ForNonNullableByDefault} (core::String) → void).{core::Object::runtimeType}{core::Type});
+  core::print(#C7.{self::C::f}{dynamic}.{core::Object::runtimeType}{core::Type});
+}
+
+constants  {
+  #C1 = static-tearoff self::m
+  #C2 = 1
+  #C3 = <core::int>[#C2]
+  #C4 = self::A<core::int> {x:#C3}
+  #C5 = instantiation self::m <core::String>
+  #C6 = self::B<core::String> {f:#C5}
+  #C7 = self::C<core::String> {f:#C5}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47154c.dart:
+- A. (from org-dartlang-testcase:///issue47154c.dart:8:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- B. (from org-dartlang-testcase:///issue47154c.dart:16:9)
+- C. (from org-dartlang-testcase:///issue47154c.dart:22:9)

pkg/front_end/testcases/constructor_tearoffs/issue47154c.dart.strong.expect

@@ -0,0 +1,46 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class A<X extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  final field core::List<self::A::X%> x;
+  const constructor •(dynamic x) → self::A<self::A::X%>
+    : self::A::x = x is{ForNonNullableByDefault} core::List<self::A::X%> ?{core::List<self::A::X%>} x{core::List<self::A::X%>} : x as{ForNonNullableByDefault} core::List<self::A::X%>, super core::Object::•()
+    ;
+}
+class B<X extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  final field (self::B::X%) → void f;
+  const constructor •() → self::B<self::B::X%>
+    : self::B::f = #C1<self::B::X%>, super core::Object::•()
+    ;
+}
+class C<X extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  final field dynamic f;
+  const constructor •() → self::C<self::C::X%>
+    : self::C::f = #C1<self::C::X%>, super core::Object::•()
+    ;
+}
+static method m<X extends core::Object? = dynamic>(self::m::X% x) → void {}
+static method main() → void {
+  #C4;
+  core::print((#C6.{self::B::f}{(core::String) → void} as{TypeError,CovarianceCheck,ForNonNullableByDefault} (core::String) → void).{core::Object::runtimeType}{core::Type});
+  core::print(#C7.{self::C::f}{dynamic}.{core::Object::runtimeType}{core::Type});
+}
+
+constants  {
+  #C1 = static-tearoff self::m
+  #C2 = 1
+  #C3 = <core::int>[#C2]
+  #C4 = self::A<core::int> {x:#C3}
+  #C5 = instantiation self::m <core::String>
+  #C6 = self::B<core::String> {f:#C5}
+  #C7 = self::C<core::String> {f:#C5}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47154c.dart:
+- A. (from org-dartlang-testcase:///issue47154c.dart:8:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- B. (from org-dartlang-testcase:///issue47154c.dart:16:9)
+- C. (from org-dartlang-testcase:///issue47154c.dart:22:9)

pkg/front_end/testcases/constructor_tearoffs/issue47154c.dart.strong.transformed.expect

@@ -0,0 +1,18 @@
+class A<X> {
+  final List<X> x;
+  const A(x) : x = x is List<X> ? x : x as List<X>;
+}
+
+void m<X>(X x) {}
+
+class B<X> {
+  final void Function(X) f;
+  const B() : f = m;
+}
+
+class C<X> {
+  final f;
+  const C() : f = m<X>;
+}
+
+void main() {}