Remove parent_level field of function type parameters.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 1215 matching lines @@
     return;
   }
   const TokenPosition token_pos = node->token_pos();
   Value* instantiator_type_arguments = NULL;
   if (type.IsInstantiated(kCurrentClass)) {
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
   Value* function_type_arguments = NULL;
-  if (type.IsInstantiated(kCurrentFunction)) {
+  if (type.IsInstantiated(kFunctions)) {
     function_type_arguments = BuildNullValue(token_pos);
   } else {
     function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
   ReturnDefinition(new (Z) InstantiateTypeInstr(
       token_pos, type, instantiator_type_arguments, function_type_arguments));
 }
 
 
 // Returns true if the type check can be skipped, for example, if the
@@ skipping 179 matching lines @@
   } else {
     Value* instantiator_type_args = BuildInstantiatorTypeArguments(token_pos);
     return PushArgument(instantiator_type_args);
   }
 }
 
 
 PushArgumentInstr* EffectGraphVisitor::PushFunctionTypeArguments(
     const AbstractType& type,
     TokenPosition token_pos) {
-  if (type.IsInstantiated(kCurrentFunction)) {
+  if (type.IsInstantiated(kFunctions)) {
     return PushArgument(BuildNullValue(token_pos));
   } else {
     Value* function_type_args = BuildFunctionTypeArguments(token_pos);
     return PushArgument(function_type_args);
   }
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue(TokenPosition token_pos) {
   return Bind(
       new (Z) ConstantInstr(Object::ZoneHandle(Z, Object::null()), token_pos));
 }
 
 
+Value* EffectGraphVisitor::BuildEmptyTypeArguments(TokenPosition token_pos) {
+  return Bind(new (Z) ConstantInstr(
+      TypeArguments::ZoneHandle(Z, Object::empty_type_arguments().raw()),
+      token_pos));
+}
+
+
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
     TokenPosition token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   Value* function_type_arguments = NULL;
   if (dst_type.IsInstantiated(kCurrentClass)) {
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
-  if (dst_type.IsInstantiated(kCurrentFunction)) {
+  if (dst_type.IsInstantiated(kFunctions)) {
     function_type_arguments = BuildNullValue(token_pos);
   } else {
     function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
 
   const intptr_t deopt_id = Thread::Current()->GetNextDeoptId();
   return new (Z) AssertAssignableInstr(
       token_pos, value, instantiator_type_arguments, function_type_arguments,
       dst_type, dst_name, deopt_id);
 }
@@ skipping 861 matching lines @@
       Class::ZoneHandle(Z, isolate()->object_store()->closure_class());
   ZoneGrowableArray<PushArgumentInstr*>* no_arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(0);
   AllocateObjectInstr* alloc = new (Z)
       AllocateObjectInstr(node->token_pos(), closure_class, no_arguments);
   alloc->set_closure_function(function);
 
   Value* closure_val = Bind(alloc);
   {
     LocalVariable* closure_tmp_var = EnterTempLocalScope(closure_val);
-    // Store instantiator type arguments if signature is uninstantiated.
+    // Store instantiator type arguments if signature is class-uninstantiated.
     if (!function.HasInstantiatedSignature(kCurrentClass)) {
       Value* closure_tmp_val =
           Bind(new (Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
       Value* type_arguments = BuildInstantiatorTypeArguments(node->token_pos());
-      Do(new (Z) StoreInstanceFieldInstr(Closure::instantiator_offset(),
-                                         closure_tmp_val, type_arguments,
-                                         kEmitStoreBarrier, node->token_pos()));
+      Do(new (Z) StoreInstanceFieldInstr(
+          Closure::instantiator_type_arguments_offset(), closure_tmp_val,
+          type_arguments, kEmitStoreBarrier, node->token_pos()));
+    }
+
+    // Store function type arguments if signature is function-uninstantiated.
+    if (!function.HasInstantiatedSignature(kFunctions)) {
+      Value* closure_tmp_val =
+          Bind(new (Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
+      Value* type_arguments = BuildFunctionTypeArguments(node->token_pos());
+      Do(new (Z) StoreInstanceFieldInstr(
+          Closure::function_type_arguments_offset(), closure_tmp_val,
+          type_arguments, kEmitStoreBarrier, node->token_pos()));
     }
 
     // Store function.
     Value* closure_tmp_val =
         Bind(new (Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
     Value* func_val =
         Bind(new (Z) ConstantInstr(Function::ZoneHandle(Z, function.raw())));
     Do(new (Z) StoreInstanceFieldInstr(Closure::function_offset(),
                                        closure_tmp_val, func_val,
                                        kEmitStoreBarrier, node->token_pos()));
@@ skipping 343 matching lines @@
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new (Z) LoadFieldInstr(
       instantiator, type_arguments_field_offset,
       Type::ZoneHandle(Z, Type::null()),  // Not an instance, no type.
       token_pos));
 }
 
 
 Value* EffectGraphVisitor::BuildFunctionTypeArguments(TokenPosition token_pos) {
-  UNIMPLEMENTED();
-  return NULL;
+  LocalVariable* function_type_arguments_var =
+      owner()->parsed_function().function_type_arguments();
+  if (function_type_arguments_var == NULL) {
+    // We encountered an uninstantiated type referring to type parameters of a
+    // signature that is local to the function being compiled. The type remains
+    // uninstantiated. Example: Foo(f<T>(T t)) => null;
+    // Foo is non-generic, but takes a generic function f as argument.
+    // The uninstantiated function type of f cannot be instantiated from within
+    // Foo and should not be instantiated. It is used in uninstantiated form to
+    // check incoming closures for assignability. We pass an empty function
+    // type argument vector.
+    return BuildEmptyTypeArguments(token_pos);
+
+    // Note that the function type could also get partially instantiated:
+    // Bar<B>(B g<T>(T t)) => null;
+    // In this case, function_type_arguments_var will not be null, since Bar
+    // is generic, and will be used to partially instantiate the type of g, more
+    // specifically the result type of g. Note that the instantiator vector will
+    // have length 1, and type parameters with indices above 0, e.g. T, must
+    // remain uninstantiated.
+  }
+  return Bind(BuildLoadLocal(*function_type_arguments_var, token_pos));
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     TokenPosition token_pos,
     const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new (Z) ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class =
       Class::ZoneHandle(Z, owner()->function().Owner());
-  Value* instantiator_type_args = BuildInstantiatorTypeArguments(token_pos);
-  const bool use_instantiator_type_args =
-      type_arguments.IsUninstantiatedIdentity() ||
-      type_arguments.CanShareInstantiatorTypeArguments(instantiator_class);
-  if (use_instantiator_type_args) {
-    return instantiator_type_args;
+  Value* instantiator_type_args = NULL;
+  if (type_arguments.IsInstantiated(kCurrentClass)) {
+    instantiator_type_args = BuildNullValue(token_pos);
+  } else {
+    instantiator_type_args = BuildInstantiatorTypeArguments(token_pos);
+    const bool use_instantiator_type_args =
+        type_arguments.IsUninstantiatedIdentity() ||
+        type_arguments.CanShareInstantiatorTypeArguments(instantiator_class);
+    if (use_instantiator_type_args) {
+      return instantiator_type_args;
+    }
   }
   Value* function_type_args = NULL;
-  if (type_arguments.IsInstantiated(kCurrentFunction)) {
+  if (type_arguments.IsInstantiated(kFunctions)) {
     function_type_args = BuildNullValue(token_pos);
   } else {
     function_type_args = BuildFunctionTypeArguments(token_pos);
   }
   return Bind(new (Z) InstantiateTypeArgumentsInstr(
       token_pos, type_arguments, instantiator_class, instantiator_type_args,
       function_type_args));
 }
 
 
@@ skipping 1600 matching lines @@
   ASSERT(type.HasResolvedTypeClass());
   const Class& type_class = Class::Handle(type.type_class());
   // Bail if the type has any type parameters.
   if (type_class.IsGeneric()) return false;
 
   // Finally a simple class for instance of checking.
   return true;
 }
 
 }  // namespace dart