Use instantiate to bound in body builder of fasta

Change-Id: I6e3d9f60c43ccb34df0b58c635be51ea0aa2e789
Reviewed-on: https://dart-review.googlesource.com/32600
Reviewed-by: Peter von der Ahé <ahe@google.com>
Reviewed-by: Paul Berry <paulberry@google.com>

pkg/analyzer/test/generated/strong_mode_kernel_test.dart

@@ -377,13 +377,6 @@ class StrongModeStaticTypeAnalyzer2Test_Kernel
     await super.test_genericMethod_tearoff();
   }
 
-  @override
-  @failingTest
-  test_implicitBounds() async {
-    // Expected: 'B<num>'
-    await super.test_implicitBounds();
-  }
-
   @override
   @failingTest
   @potentialAnalyzerProblem
@@ -391,13 +384,6 @@ class StrongModeStaticTypeAnalyzer2Test_Kernel
     return super.test_instantiateToBounds_class_error_recursion();
   }
 
-  @override
-  @failingTest
-  test_instantiateToBounds_class_ok_simpleBounds() async {
-    // Expected: 'B<num>'
-    await super.test_instantiateToBounds_class_ok_simpleBounds();
-  }
-
   @override
   @failingTest
   test_notInstantiatedBound_direct_class_class() async {

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

@@ -1852,7 +1852,7 @@ class BodyBuilder extends ScopeListener<JumpTarget> implements BuilderHelper {
       }
     }
     if (name is TypeDeclarationAccessor) {
-      push(name.buildType(arguments));
+      push(name.buildTypeWithBuiltArguments(arguments));
     } else if (name is FastaAccessor) {
       addProblem(fasta.templateNotAType.withArguments(beginToken.lexeme),
           beginToken.charOffset);

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

@@ -47,11 +47,15 @@ import 'kernel_builder.dart'
         Builder,
         FunctionTypeAliasBuilder,
         KernelClassBuilder,
+        KernelFunctionTypeAliasBuilder,
         KernelInvalidTypeBuilder,
+        KernelLibraryBuilder,
+        KernelTypeVariableBuilder,
         LibraryBuilder,
         LoadLibraryBuilder,
         PrefixBuilder,
-        TypeDeclarationBuilder;
+        TypeDeclarationBuilder,
+        KernelTypeBuilder;
 
 import 'kernel_shadow_ast.dart'
     show
@@ -65,10 +69,10 @@ import 'kernel_shadow_ast.dart'
         ShadowTypeLiteral,
         ShadowVariableAssignment;
 
-import 'kernel_type_variable_builder.dart' show KernelTypeVariableBuilder;
-
 import 'utils.dart' show offsetForToken;
 
+import 'type_algorithms.dart' show calculateBoundsForDeclaration;
+
 abstract class BuilderHelper {
   LibraryBuilder get library;
 
@@ -1050,8 +1054,8 @@ class TypeDeclarationAccessor extends ReadOnlyAccessor {
               ..fileOffset = offsetForToken(token))
           ..fileOffset = offset;
       } else {
-        super.expression = new ShadowTypeLiteral(
-            prefix?.name, buildType(null, nonInstanceAccessIsError: true))
+        super.expression = new ShadowTypeLiteral(prefix?.name,
+            buildTypeWithBuiltArguments(null, nonInstanceAccessIsError: true))
           ..fileOffset = offsetForToken(token);
       }
     }
@@ -1111,7 +1115,7 @@ class TypeDeclarationAccessor extends ReadOnlyAccessor {
     }
   }
 
-  DartType buildType(List<DartType> arguments,
+  DartType buildTypeWithBuiltArguments(List<DartType> arguments,
       {bool nonInstanceAccessIsError: false}) {
     if (arguments != null) {
       int expected = 0;
@@ -1138,8 +1142,68 @@ class TypeDeclarationAccessor extends ReadOnlyAccessor {
         arguments = null;
       }
     }
-    DartType type =
-        declaration.buildTypesWithBuiltArguments(helper.library, arguments);
+
+    DartType type;
+    LibraryBuilder helperLibrary = helper.library;
+    if (arguments == null &&
+        helperLibrary is KernelLibraryBuilder &&
+        helperLibrary.loader.target.strongMode) {
+      TypeDeclarationBuilder typeDeclaration = declaration;
+      if (typeDeclaration is KernelClassBuilder) {
+        typeDeclaration.calculatedBounds ??= calculateBoundsForDeclaration(
+            typeDeclaration,
+            helperLibrary.loader.target.dynamicType,
+            helperLibrary.loader.coreLibrary["Object"]);
+        type = typeDeclaration.buildType(
+            helper.library, typeDeclaration.calculatedBounds);
+      } else if (typeDeclaration is KernelFunctionTypeAliasBuilder) {
+        typeDeclaration.calculatedBounds ??= calculateBoundsForDeclaration(
+            typeDeclaration,
+            helperLibrary.loader.target.dynamicType,
+            helperLibrary.loader.coreLibrary["Object"]);
+        type = typeDeclaration.buildType(
+            helper.library, typeDeclaration.calculatedBounds);
+      }
+    }
+    if (type == null) {
+      type =
+          declaration.buildTypesWithBuiltArguments(helper.library, arguments);
+    }
+    if (type is TypeParameterType) {
+      return helper.validatedTypeVariableUse(
+          type, offsetForToken(token), nonInstanceAccessIsError);
+    }
+    return type;
+  }
+
+  DartType buildType(List<KernelTypeBuilder> arguments,
+      {bool nonInstanceAccessIsError: false}) {
+    if (arguments != null) {
+      int expected = 0;
+      if (declaration is KernelClassBuilder) {
+        expected = declaration.target.typeParameters.length;
+      } else if (declaration is FunctionTypeAliasBuilder) {
+        expected = declaration.target.typeParameters.length;
+      } else if (declaration is KernelTypeVariableBuilder) {
+        // Type arguments on a type variable - error reported elsewhere.
+      } else {
+        return unhandled(
+            "${declaration.runtimeType}",
+            "TypeDeclarationAccessor.buildType",
+            offsetForToken(token),
+            helper.uri);
+      }
+      if (arguments.length != expected) {
+        helper.warnTypeArgumentsMismatch(
+            declaration.name, expected, offsetForToken(token));
+        // We ignore the provided arguments, which will in turn return the
+        // raw type below.
+        // TODO(sigmund): change to use an InvalidType and include the raw type
+        // as a recovery node once the IR can represent it (Issue #29840).
+        arguments = null;
+      }
+    }
+    DartType type = declaration.buildType(helper.library, arguments);
     if (type is TypeParameterType) {
       return helper.validatedTypeVariableUse(
           type, offsetForToken(token), nonInstanceAccessIsError);

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

@@ -9,7 +9,9 @@ import 'kernel_builder.dart'
         KernelNamedTypeBuilder,
         KernelTypeVariableBuilder,
         KernelClassBuilder,
-        KernelFunctionTypeAliasBuilder;
+        KernelFunctionTypeAliasBuilder,
+        NamedTypeBuilder,
+        TypeDeclarationBuilder;
 
 KernelTypeBuilder substituteRec(
     KernelTypeBuilder type,
@@ -75,3 +77,35 @@ List<KernelTypeBuilder> calculateBounds(
   }
   return result;
 }
+
+List<KernelTypeBuilder> calculateBoundsForDeclaration(
+    TypeDeclarationBuilder typeDeclarationBuilder,
+    KernelTypeBuilder dynamicType,
+    KernelClassBuilder objectClass) {
+  List<TypeVariableBuilder> typeParameters;
+
+  if (typeDeclarationBuilder is KernelClassBuilder) {
+    typeParameters = typeDeclarationBuilder.typeVariables;
+  } else if (typeDeclarationBuilder is KernelFunctionTypeAliasBuilder) {
+    typeParameters = typeDeclarationBuilder.typeVariables;
+  }
+
+  if (typeParameters == null || typeParameters.length == 0) {
+    return null;
+  }
+
+  return calculateBounds(typeParameters, dynamicType, objectClass);
+}
+
+int instantiateToBoundInPlace(NamedTypeBuilder typeBuilder,
+    KernelTypeBuilder dynamicType, KernelClassBuilder objectClass) {
+  int count = 0;
+
+  if (typeBuilder.arguments == null) {
+    typeBuilder.arguments = calculateBoundsForDeclaration(
+        typeBuilder.builder, dynamicType, objectClass);
+    count = typeBuilder.arguments?.length ?? 0;
+  }
+
+  return count;
+}

pkg/front_end/testcases/strong.status

@@ -110,8 +110,6 @@ inference_new/infer_assign_to_index_upwards: TypeCheckError
 inference_new/infer_field_getter_setter_mismatch: TypeCheckError
 inference_new/infer_field_override_getter_overrides_setter: TypeCheckError
 
-instantiate_to_bound/typedef_literal_map: Fail
-instantiate_to_bound/typedef_literal_list: Fail
 instantiate_to_bound/typedef_super_bounded_type: Fail
 
 rasta/abstract_constructor: Fail