[fasta] Run instantiate-to-bound on functions

Change-Id: Icff76f2e8f309b6d96059839f05b3ec4cc61510d
Reviewed-on: https://dart-review.googlesource.com/50945
Reviewed-by: Peter von der Ahé <[email protected]>

Author: Dmitry Stefantsov

pkg/front_end/lib/src/fasta/builder/library_builder.dart

@@ -176,7 +176,7 @@ abstract class LibraryBuilder<T extends TypeBuilder, R>
   /// where they were omitted by the programmer and not provided by the type
   /// inference.  The method returns the number of distinct type variables
   /// that were instantiated in this library.
-  int instantiateToBound(TypeBuilder dynamicType, TypeBuilder bottomType,
+  int computeDefaultTypes(TypeBuilder dynamicType, TypeBuilder bottomType,
       ClassBuilder objectClass) {
     return 0;
   }

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

@@ -122,6 +122,8 @@ import 'kernel_ast_api.dart' as kernel show Expression, Statement;
 
 import 'kernel_builder.dart';
 
+import 'type_algorithms.dart' show calculateBounds;
+
 // TODO(ahe): Remove this and ensure all nodes have a location.
 const noLocation = null;
 
@@ -3641,9 +3643,25 @@ abstract class BodyBuilder<Expression, Statement, Arguments>
   void beginTypeVariables(Token token) {
     debugEvent("beginTypeVariables");
     OutlineBuilder listener = new OutlineBuilder(library);
+    // TODO(dmitryas):  [ClassMemberParser] shouldn't be used to parse and build
+    // the type variables for the local function.  It also causes the unresolved
+    // types from the bounds of the type variables to appear in [library.types].
+    // See the code that resolves them below.
     new ClassMemberParser(listener)
         .parseTypeVariablesOpt(new Token.eof(-1)..next = token);
     enterFunctionTypeScope(listener.pop());
+
+    // The invocation of [enterFunctionTypeScope] above has put the type
+    // variables into the scope, and now the possibly unresolved types from
+    // the bounds of the variables can be resolved.  This is needed to apply
+    // instantiate-to-bound later.
+    // TODO(dmitryas):  Move the resolution to the appropriate place once
+    // [ClassMemberParser] is not used to build the type variables for the local
+    // function.  See the comment above.
+    for (UnresolvedType t in library.types) {
+      t.resolveIn(scope);
+    }
+    library.types.clear();
   }
 
   @override
@@ -3676,15 +3694,40 @@ abstract class BodyBuilder<Expression, Statement, Arguments>
         variable.parameter.addAnnotation(toKernelExpression(annotation));
       }
     }
-    push(variable
-      ..finish(library, library.loader.target.objectClassBuilder,
-          library.loader.target.dynamicType));
+    push(variable);
   }
 
   @override
   void endTypeVariables(int count, Token beginToken, Token endToken) {
     debugEvent("TypeVariables");
-    push(popList(count) ?? NullValue.TypeVariables);
+    List<KernelTypeVariableBuilder> typeVariables = popList(count);
+    if (typeVariables != null) {
+      if (library.loader.target.strongMode) {
+        List<KernelTypeBuilder> calculatedBounds = calculateBounds(
+            typeVariables,
+            library.loader.target.dynamicType,
+            library.loader.target.bottomType,
+            library.loader.target.objectClassBuilder);
+        for (int i = 0; i < typeVariables.length; ++i) {
+          typeVariables[i].defaultType = calculatedBounds[i];
+          typeVariables[i].defaultType.resolveIn(
+              scope, typeVariables[i].charOffset, typeVariables[i].fileUri);
+          typeVariables[i].finish(
+              library,
+              library.loader.target.objectClassBuilder,
+              library.loader.target.dynamicType);
+        }
+      } else {
+        for (int i = 0; i < typeVariables.length; ++i) {
+          typeVariables[i].defaultType = library.loader.target.dynamicType;
+          typeVariables[i].finish(
+              library,
+              library.loader.target.objectClassBuilder,
+              library.loader.target.dynamicType);
+        }
+      }
+    }
+    push(typeVariables ?? NullValue.TypeVariables);
   }
 
   List<TypeParameter> typeVariableBuildersToKernel(List typeVariableBuilders) {

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

@@ -990,47 +990,35 @@ class KernelLibraryBuilder
     return count;
   }
 
-  int instantiateToBound(TypeBuilder dynamicType, TypeBuilder bottomType,
+  int computeDefaultTypes(TypeBuilder dynamicType, TypeBuilder bottomType,
       ClassBuilder objectClass) {
     int count = 0;
+    bool strongMode = loader.target.strongMode;
+
+    int computeDefaultTypesForVariables(List<TypeVariableBuilder> variables) {
+      if (variables == null) return 0;
+      List<KernelTypeBuilder> calculatedBounds = strongMode
+          ? calculateBounds(variables, dynamicType, bottomType, objectClass)
+          : null;
+      for (int i = 0; i < variables.length; ++i) {
+        variables[i].defaultType =
+            strongMode ? calculatedBounds[i] : dynamicType;
+      }
+      return variables.length;
+    }
 
     for (var declaration in libraryDeclaration.members.values) {
       if (declaration is KernelClassBuilder) {
-        if (declaration.typeVariables != null) {
-          List<KernelTypeBuilder> calculatedBounds;
-          if (loader.target.strongMode) {
-            calculatedBounds = calculateBounds(declaration.typeVariables,
-                dynamicType, bottomType, objectClass);
-          } else {
-            calculatedBounds =
-                new List<KernelTypeBuilder>(declaration.typeVariables.length);
-            for (int i = 0; i < calculatedBounds.length; ++i) {
-              calculatedBounds[i] = dynamicType;
-            }
+        count += computeDefaultTypesForVariables(declaration.typeVariables);
+        declaration.forEach((String name, Builder member) {
+          if (member is KernelProcedureBuilder) {
+            count += computeDefaultTypesForVariables(member.typeVariables);
           }
-          for (int i = 0; i < calculatedBounds.length; ++i) {
-            declaration.typeVariables[i].defaultType = calculatedBounds[i];
-          }
-          count += calculatedBounds.length;
-        }
+        });
       } else if (declaration is KernelFunctionTypeAliasBuilder) {
-        if (declaration.typeVariables != null) {
-          List<KernelTypeBuilder> calculatedBounds;
-          if (loader.target.strongMode) {
-            calculatedBounds = calculateBounds(declaration.typeVariables,
-                dynamicType, bottomType, objectClass);
-          } else {
-            calculatedBounds =
-                new List<KernelTypeBuilder>(declaration.typeVariables.length);
-            for (int i = 0; i < calculatedBounds.length; ++i) {
-              calculatedBounds[i] = dynamicType;
-            }
-          }
-          for (int i = 0; i < calculatedBounds.length; ++i) {
-            declaration.typeVariables[i].defaultType = calculatedBounds[i];
-          }
-          count += calculatedBounds.length;
-        }
+        count += computeDefaultTypesForVariables(declaration.typeVariables);
+      } else if (declaration is KernelFunctionBuilder) {
+        count += computeDefaultTypesForVariables(declaration.typeVariables);
       }
     }
 

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

@@ -242,7 +242,7 @@ class KernelTarget extends TargetImplementation {
       objectType.bind(loader.coreLibrary["Object"]);
       bottomType.bind(loader.coreLibrary["Null"]);
       loader.resolveTypes();
-      loader.instantiateToBound(dynamicType, bottomType, objectClassBuilder);
+      loader.computeDefaultTypes(dynamicType, bottomType, objectClassBuilder);
       List<SourceClassBuilder> myClasses = collectMyClasses();
       loader.checkSemantics(myClasses);
       loader.finishTypeVariables(objectClassBuilder, dynamicType);

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

@@ -396,16 +396,16 @@ class SourceLoader<L> extends Loader<L> {
     ticker.logMs("Resolved $count type-variable bounds");
   }
 
-  void instantiateToBound(TypeBuilder dynamicType, TypeBuilder bottomType,
+  void computeDefaultTypes(TypeBuilder dynamicType, TypeBuilder bottomType,
       ClassBuilder objectClass) {
     int count = 0;
     builders.forEach((Uri uri, LibraryBuilder library) {
       if (library.loader == this) {
         count +=
-            library.instantiateToBound(dynamicType, bottomType, objectClass);
+            library.computeDefaultTypes(dynamicType, bottomType, objectClass);
       }
     });
-    ticker.logMs("Instantiated $count type variables to their bounds");
+    ticker.logMs("Computed default types for $count type variables");
   }
 
   void finishNativeMethods() {