[kernel] Delay type finalization when parsing function types.

Currently, the Kernel FE doesn't set up parent pointers correctly for
signature function types. This prevents type parameters on generic
function types from being finalized correctly. In addition, finalization
of generic interface types within a generic function type can crash if they
reference not-yet-finalized type parameters of the enclosing function type.

This review solves both issues. Several failing tests pass again, although
more thorough testing is blocked on Github issue #31213 (nested generic function
types crashing in Fasta).

Bug:
Change-Id: Ib5ee6b2566492e3fd6688fe5a6b6976692562ea1
Reviewed-on: https://dart-review.googlesource.com/16360
Reviewed-by: Régis Crelier <[email protected]>

Author: sjindel-google

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -2226,17 +2226,28 @@ void StreamingDartTypeTranslator::BuildInterfaceType(bool simple) {
 
 void StreamingDartTypeTranslator::BuildFunctionType(bool simple) {
   Function& signature_function = Function::ZoneHandle(
-      Z,
-      Function::NewSignatureFunction(*active_class_->klass, Function::Handle(Z),
-                                     TokenPosition::kNoSource));
+      Z, Function::NewSignatureFunction(*active_class_->klass,
+                                        active_class_->enclosing != NULL
+                                            ? *active_class_->enclosing
+                                            : Function::Handle(Z),
+                                        TokenPosition::kNoSource));
+
+  // Suspend finalization of types inside this one. They will be finalized after
+  // the whole function type is constructed.
+  //
+  // TODO(31213): Test further when nested generic function types
+  // are supported by fasta.
+  bool finalize = finalize_;
+  finalize_ = false;
 
   if (!simple) {
     builder_->LoadAndSetupTypeParameters(active_class_, signature_function,
                                          builder_->ReadListLength(),
                                          signature_function);
   }
+
   ActiveTypeParametersScope scope(
-      active_class_,
+      active_class_, &signature_function,
       TypeArguments::Handle(Z, signature_function.type_parameters()), Z);
 
   intptr_t required_count;
@@ -2306,6 +2317,8 @@ void StreamingDartTypeTranslator::BuildFunctionType(bool simple) {
   }
   signature_function.set_result_type(result_);
 
+  finalize_ = finalize;
+
   Type& signature_type =
       Type::ZoneHandle(Z, signature_function.SignatureType());
 
@@ -8073,7 +8086,11 @@ void StreamingFlowGraphBuilder::LoadAndSetupTypeParameters(
     Function::Cast(set_on).set_type_parameters(type_parameters);
   }
 
-  ActiveTypeParametersScope(active_class, type_parameters, Z);
+  const Function* enclosing = NULL;
+  if (!parameterized_function.IsNull()) {
+    enclosing = &parameterized_function;
+  }
+  ActiveTypeParametersScope(active_class, enclosing, type_parameters, Z);
 
   // Step b) Fill in the bounds of all [TypeParameter]s.
   for (intptr_t i = 0; i < type_parameter_count; i++) {
@@ -8117,7 +8134,8 @@ void StreamingFlowGraphBuilder::SetupFunctionParameters(
   }
 
   ActiveTypeParametersScope scope(
-      active_class, TypeArguments::Handle(Z, function.type_parameters()), Z);
+      active_class, &function,
+      TypeArguments::Handle(Z, function.type_parameters()), Z);
 
   function_node_helper->ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -30,6 +30,8 @@ ActiveTypeParametersScope::ActiveTypeParametersScope(ActiveClass* active_class,
                                                      const Function& innermost,
                                                      Zone* Z)
     : active_class_(active_class), saved_(*active_class) {
+  active_class_->enclosing = &innermost;
+
   intptr_t num_params = 0;
 
   Function& f = Function::Handle(Z);
@@ -58,9 +60,12 @@ ActiveTypeParametersScope::ActiveTypeParametersScope(ActiveClass* active_class,
 
 ActiveTypeParametersScope::ActiveTypeParametersScope(
     ActiveClass* active_class,
+    const Function* function,
     const TypeArguments& new_params,
     Zone* Z)
     : active_class_(active_class), saved_(*active_class) {
+  active_class_->enclosing = function;
+
   if (new_params.IsNull()) return;
 
   const TypeArguments* old_params = active_class->local_type_parameters;

runtime/vm/compiler/frontend/kernel_to_il.h

@@ -190,7 +190,11 @@ typedef ZoneGrowableArray<PushArgumentInstr*>* ArgumentArray;
 
 class ActiveClass {
  public:
-  ActiveClass() : klass(NULL), member(NULL), local_type_parameters(NULL) {}
+  ActiveClass()
+      : klass(NULL),
+        member(NULL),
+        enclosing(NULL),
+        local_type_parameters(NULL) {}
 
   bool HasMember() { return member != NULL; }
 
@@ -221,6 +225,10 @@ class ActiveClass {
 
   const Function* member;
 
+  // The innermost enclosing function. This is used for building types, as a
+  // parent for function types.
+  const Function* enclosing;
+
   const TypeArguments* local_type_parameters;
 };
 
@@ -258,14 +266,20 @@ class ActiveTypeParametersScope {
   // Set the local type parameters of the ActiveClass to be exactly all type
   // parameters defined by 'innermost' and any enclosing *closures* (but not
   // enclosing methods/top-level functions/classes).
+  //
+  // Also, the enclosing function is set to 'innermost'.
   ActiveTypeParametersScope(ActiveClass* active_class,
                             const Function& innermost,
                             Zone* Z);
 
   // Append the list of the local type parameters to the list in ActiveClass.
+  //
+  // Also, the enclosing function is set to 'function'.
   ActiveTypeParametersScope(ActiveClass* active_class,
+                            const Function* function,
                             const TypeArguments& new_params,
                             Zone* Z);
+
   ~ActiveTypeParametersScope() { *active_class_ = saved_; }
 
  private:

tests/corelib_2/corelib_2.status

@@ -312,9 +312,6 @@ string_from_environment3_test/02: MissingCompileTimeError
 string_from_environment3_test/03: MissingCompileTimeError
 string_from_environment3_test/04: MissingCompileTimeError
 
-[ ($compiler == dartk || $compiler == dartkp) && ($runtime == vm || $runtime == dart_precompiled) && $mode == debug]
-list_test/*: Crash
-
 [ $compiler == dartkp ]
 apply3_test: Crash
 from_environment_const_type_test/02: MissingCompileTimeError

tests/language_2/language_2_kernel.status

@@ -674,11 +674,6 @@ cyclic_type_variable_test/none: Crash
 type_parameter_test/04: Crash
 type_parameter_test/05: Crash
 const_instance_field_test/01: Crash
-generic_function_typedef_test/none: Crash
-generic_function_typedef_test/01: Crash
-generic_local_functions_test: Crash
-generic_methods_closure_test: Crash
-generic_typedef_test: Crash
 
 [ $compiler == none || $compiler == app_jit || $compiler == dartk || $runtime == dart_precompiled ]
 constructor3_test: Fail, OK, Pass