Pass a second type argument vector to all type instantiation calls in the VM.

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 216 matching lines @@
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.IsInstantiated() &&
           (type_arguments.Length() >= cls.NumTypeArguments())));
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type.
 // Arg0: uninstantiated type.
 // Arg1: instantiator type arguments.
+// Arg2: function type arguments.
 // Return value: instantiated type.
-DEFINE_RUNTIME_ENTRY(InstantiateType, 2) {
+DEFINE_RUNTIME_ENTRY(InstantiateType, 3) {
   AbstractType& type = AbstractType::CheckedHandle(zone, arguments.ArgAt(0));
-  const TypeArguments& instantiator =
+  const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
+  const TypeArguments& function_type_arguments =
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
   ASSERT(!type.IsNull() && !type.IsInstantiated());
-  ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
+  ASSERT(instantiator_type_arguments.IsNull() ||
+         instantiator_type_arguments.IsInstantiated());
+  ASSERT(function_type_arguments.IsNull() ||
+         function_type_arguments.IsInstantiated());
   Error& bound_error = Error::Handle(zone);
   type =
-      type.InstantiateFrom(instantiator, &bound_error, NULL, NULL, Heap::kOld);
+      type.InstantiateFrom(instantiator_type_arguments, function_type_arguments,
+                           &bound_error, NULL, NULL, Heap::kOld);
   if (!bound_error.IsNull()) {
     // Throw a dynamic type error.
     const TokenPosition location = GetCallerLocation();
     String& bound_error_message =
         String::Handle(zone, String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(location, AbstractType::Handle(zone),
                                         AbstractType::Handle(zone),
                                         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   if (type.IsTypeRef()) {
     type = TypeRef::Cast(type).type();
     ASSERT(!type.IsTypeRef());
     ASSERT(type.IsCanonical());
   }
   ASSERT(!type.IsNull() && type.IsInstantiated());
   arguments.SetReturn(type);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
+// Arg2: function type arguments.
 // Return value: instantiated type arguments.
-DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
+DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 3) {
   TypeArguments& type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(0));
-  const TypeArguments& instantiator =
+  const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
+  const TypeArguments& function_type_arguments =
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
   ASSERT(!type_arguments.IsNull() && !type_arguments.IsInstantiated());
-  ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
+  ASSERT(instantiator_type_arguments.IsNull() ||
+         instantiator_type_arguments.IsInstantiated());
+  ASSERT(function_type_arguments.IsNull() ||
+         function_type_arguments.IsInstantiated());
   // Code inlined in the caller should have optimized the case where the
   // instantiator can be reused as type argument vector.
   ASSERT(!type_arguments.IsUninstantiatedIdentity());
   if (isolate->type_checks()) {
     Error& bound_error = Error::Handle(zone);
     type_arguments = type_arguments.InstantiateAndCanonicalizeFrom(
-        instantiator, &bound_error);
+        instantiator_type_arguments, function_type_arguments, &bound_error);
     if (!bound_error.IsNull()) {
       // Throw a dynamic type error.
       const TokenPosition location = GetCallerLocation();
       String& bound_error_message =
           String::Handle(zone, String::New(bound_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
           location, AbstractType::Handle(zone), AbstractType::Handle(zone),
           Symbols::Empty(), bound_error_message);
       UNREACHABLE();
     }
   } else {
-    type_arguments =
-        type_arguments.InstantiateAndCanonicalizeFrom(instantiator, NULL);
+    type_arguments = type_arguments.InstantiateAndCanonicalizeFrom(
+        instantiator_type_arguments, function_type_arguments, NULL);
   }
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new context large enough to hold the given number of variables.
 // Arg0: number of variables.
 // Return value: newly allocated context.
 DEFINE_RUNTIME_ENTRY(AllocateContext, 1) {
@@ skipping 18 matching lines @@
   }
   arguments.SetReturn(cloned_ctx);
 }
 
 
 // Helper routine for tracing a type check.
 static void PrintTypeCheck(const char* message,
                            const Instance& instance,
                            const AbstractType& type,
                            const TypeArguments& instantiator_type_arguments,
+                           const TypeArguments& function_type_arguments,
                            const Bool& result) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const AbstractType& instance_type =
       AbstractType::Handle(instance.GetType(Heap::kNew));
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
     OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n", message,
                  String::Handle(instance_type.Name()).ToCString(),
                  Class::Handle(instance_type.type_class()).id(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(type.Name()).ToCString(),
                  Class::Handle(type.type_class()).id(), caller_frame->pc());
   } else {
     // Instantiate type before printing.
     Error& bound_error = Error::Handle();
     const AbstractType& instantiated_type =
         AbstractType::Handle(type.InstantiateFrom(
-            instantiator_type_arguments, &bound_error, NULL, NULL, Heap::kOld));
+            instantiator_type_arguments, function_type_arguments, &bound_error,
+            NULL, NULL, Heap::kOld));
     OS::PrintErr("%s: '%s' %s '%s' instantiated from '%s' (pc: %#" Px ").\n",
                  message, String::Handle(instance_type.Name()).ToCString(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(instantiated_type.Name()).ToCString(),
                  String::Handle(type.Name()).ToCString(), caller_frame->pc());
     if (!bound_error.IsNull()) {
       OS::Print("  bound error: %s\n", bound_error.ToErrorCString());
     }
   }
   const Function& function =
       Function::Handle(caller_frame->LookupDartFunction());
   OS::PrintErr(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
 
-// This updates the type test cache, an array containing 4-value elements
+// This updates the type test cache, an array containing 5-value elements
 // (instance class (or function if the instance is a closure), instance type
-// arguments, instantiator type arguments and test_result). It can be applied to
-// classes with type arguments in which case it contains just the result of the
-// class subtype test, not including the evaluation of type arguments.
+// arguments, instantiator type arguments, function type arguments,
+// and test_result). It can be applied to classes with type arguments in which
+// case it contains just the result of the class subtype test, not including the
+// evaluation of type arguments.
 // This operation is currently very slow (lookup of code is not efficient yet).
 static void UpdateTypeTestCache(
     const Instance& instance,
     const AbstractType& type,
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     const Bool& result,
     const SubtypeTestCache& new_cache) {
   // Since the test is expensive, don't do it unless necessary.
   // The list of disallowed cases will decrease as they are implemented in
   // inlined assembly.
   if (new_cache.IsNull()) {
     if (FLAG_trace_type_checks) {
       OS::Print("UpdateTypeTestCache: cache is null\n");
     }
     return;
   }
   if (instance.IsSmi()) {
     if (FLAG_trace_type_checks) {
       OS::Print("UpdateTypeTestCache: instance is Smi\n");
     }
     return;
   }
+  // If the type is uninstantiated and refers to parent function type
+  // parameters, the context is required in the type test and the cache
+  // therefore cannot be used.
+  if (!type.IsInstantiated(kParentFunctions)) {
+    if (FLAG_trace_type_checks) {
+      OS::Print(
+          "UpdateTypeTestCache: type refers to parent function's type "
+          "parameters\n");
+    }
+    return;
+  }
   const Class& instance_class = Class::Handle(instance.clazz());
   Object& instance_class_id_or_function = Object::Handle();
   TypeArguments& instance_type_arguments = TypeArguments::Handle();
   if (instance_class.IsClosureClass()) {
     instance_class_id_or_function = Closure::Cast(instance).function();
     instance_type_arguments = Closure::Cast(instance).instantiator();
   } else {
     instance_class_id_or_function = Smi::New(instance_class.id());
     if (instance_class.NumTypeArguments() > 0) {
       instance_type_arguments = instance.GetTypeArguments();
     }
   }
   const intptr_t len = new_cache.NumberOfChecks();
   if (len >= FLAG_max_subtype_cache_entries) {
     return;
   }
 #if defined(DEBUG)
   ASSERT(instance_type_arguments.IsNull() ||
          instance_type_arguments.IsCanonical());
   ASSERT(instantiator_type_arguments.IsNull() ||
          instantiator_type_arguments.IsCanonical());
+  ASSERT(function_type_arguments.IsNull() ||
+         function_type_arguments.IsCanonical());
   Object& last_instance_class_id_or_function = Object::Handle();
   TypeArguments& last_instance_type_arguments = TypeArguments::Handle();
   TypeArguments& last_instantiator_type_arguments = TypeArguments::Handle();
+  TypeArguments& last_function_type_arguments = TypeArguments::Handle();
   Bool& last_result = Bool::Handle();
   for (intptr_t i = 0; i < len; ++i) {
     new_cache.GetCheck(i, &last_instance_class_id_or_function,
                        &last_instance_type_arguments,
-                       &last_instantiator_type_arguments, &last_result);
+                       &last_instantiator_type_arguments,
+                       &last_function_type_arguments, &last_result);
     if ((last_instance_class_id_or_function.raw() ==
          instance_class_id_or_function.raw()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
-         instantiator_type_arguments.raw())) {
+         instantiator_type_arguments.raw()) &&
+        (last_function_type_arguments.raw() ==
+         last_function_type_arguments.raw())) {
       OS::PrintErr("  Error in test cache %p ix: %" Pd ",", new_cache.raw(), i);
       PrintTypeCheck(" duplicate cache entry", instance, type,
-                     instantiator_type_arguments, result);
+                     instantiator_type_arguments, function_type_arguments,
+                     result);
       UNREACHABLE();
       return;
     }
   }
 #endif
   new_cache.AddCheck(instance_class_id_or_function, instance_type_arguments,
-                     instantiator_type_arguments, result);
+                     instantiator_type_arguments, function_type_arguments,
+                     result);
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       Error& bound_error = Error::Handle();
       test_type = type.InstantiateFrom(instantiator_type_arguments,
-                                       &bound_error, NULL, NULL, Heap::kNew);
+                                       function_type_arguments, &bound_error,
+                                       NULL, NULL, Heap::kNew);
       ASSERT(bound_error.IsNull());  // Malbounded types are not optimized.
     }
     OS::PrintErr(
         "  Updated test cache %p ix: %" Pd
         " with "
-        "(cid-or-fun: %p, type-args: %p, instantiator: %p, result: %s)\n"
+        "(cid-or-fun: %p, type-args: %p, i-type-args: %p, f-type-args: %p, "
+        "result: %s)\n"
         "    instance  [class: (%p '%s' cid: %" Pd
         "),    type-args: %p %s]\n"
-        "    test-type [class: (%p '%s' cid: %" Pd "), in-type-args: %p %s]\n",
+        "    test-type [class: (%p '%s' cid: %" Pd
+        "), i-type-args: %p %s, "
+        ", f-type-args: %p %s]\n",
         new_cache.raw(), len,
 
         instance_class_id_or_function.raw(), instance_type_arguments.raw(),
-        instantiator_type_arguments.raw(), result.ToCString(),
+        instantiator_type_arguments.raw(), instantiator_type_arguments.raw(),
+        result.ToCString(),
 
         instance_class.raw(), String::Handle(instance_class.Name()).ToCString(),
         instance_class.id(), instance_type_arguments.raw(),
         instance_type_arguments.ToCString(),
 
         test_type.type_class(),
         String::Handle(Class::Handle(test_type.type_class()).Name())
             .ToCString(),
         Class::Handle(test_type.type_class()).id(),
         instantiator_type_arguments.raw(),
+        instantiator_type_arguments.ToCString(),
+        instantiator_type_arguments.raw(),
         instantiator_type_arguments.ToCString());
   }
 }
 
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: instance being checked.
 // Arg1: type.
 // Arg2: type arguments of the instantiator of the type.
-// Arg3: SubtypeTestCache.
+// Arg3: type arguments of the function of the type.
+// Arg4: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
-DEFINE_RUNTIME_ENTRY(Instanceof, 4) {
+DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
   const Instance& instance = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const AbstractType& type =
       AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
+  const TypeArguments& function_type_arguments =
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(3));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(3));
+      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(4));
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsMalformed());    // Already checked in code generator.
   ASSERT(!type.IsMalbounded());   // Already checked in code generator.
   ASSERT(!type.IsDynamicType());  // No need to check assignment.
   Error& bound_error = Error::Handle(zone);
-  const Bool& result = Bool::Get(
-      instance.IsInstanceOf(type, instantiator_type_arguments, &bound_error));
+  const Bool& result =
+      Bool::Get(instance.IsInstanceOf(type, instantiator_type_arguments,
+                                      function_type_arguments, &bound_error));
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf", instance, type, instantiator_type_arguments,
-                   result);
+                   function_type_arguments, result);
   }
   if (!result.value() && !bound_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const TokenPosition location = GetCallerLocation();
     String& bound_error_message =
         String::Handle(zone, String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(location, AbstractType::Handle(zone),
                                         AbstractType::Handle(zone),
                                         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
-  UpdateTypeTestCache(instance, type, instantiator_type_arguments, result,
-                      cache);
+  UpdateTypeTestCache(instance, type, instantiator_type_arguments,
+                      function_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
 // Arg0: instance being assigned.
 // Arg1: type being assigned to.
 // Arg2: type arguments of the instantiator of the type being assigned to.
-// Arg3: name of variable being assigned to.
-// Arg4: SubtypeTestCache.
+// Arg3: type arguments of the function of the type being assigned to.
+// Arg4: name of variable being assigned to.
+// Arg5: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
-DEFINE_RUNTIME_ENTRY(TypeCheck, 5) {
+DEFINE_RUNTIME_ENTRY(TypeCheck, 6) {
   const Instance& src_instance =
       Instance::CheckedHandle(zone, arguments.ArgAt(0));
   AbstractType& dst_type =
       AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
-  const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(3));
+  const TypeArguments& function_type_arguments =
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(3));
+  const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(4));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(4));
+      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(5));
   ASSERT(!dst_type.IsMalformed());    // Already checked in code generator.
   ASSERT(!dst_type.IsMalbounded());   // Already checked in code generator.
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
   ASSERT(!src_instance.IsNull());     // Already checked in inlined code.
 
   Error& bound_error = Error::Handle(zone);
-  const bool is_instance_of = src_instance.IsInstanceOf(
-      dst_type, instantiator_type_arguments, &bound_error);
+  const bool is_instance_of =
+      src_instance.IsInstanceOf(dst_type, instantiator_type_arguments,
+                                function_type_arguments, &bound_error);
 
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("TypeCheck", src_instance, dst_type,
-                   instantiator_type_arguments, Bool::Get(is_instance_of));
+                   instantiator_type_arguments, function_type_arguments,
+                   Bool::Get(is_instance_of));
   }
   if (!is_instance_of) {
     // Throw a dynamic type error.
     const TokenPosition location = GetCallerLocation();
     const AbstractType& src_type =
         AbstractType::Handle(zone, src_instance.GetType(Heap::kNew));
     if (!dst_type.IsInstantiated()) {
       // Instantiate dst_type before reporting the error.
-      dst_type = dst_type.InstantiateFrom(instantiator_type_arguments, NULL,
-                                          NULL, NULL, Heap::kNew);
+      dst_type = dst_type.InstantiateFrom(instantiator_type_arguments,
+                                          function_type_arguments, NULL, NULL,
+                                          NULL, Heap::kNew);
       // Note that instantiated dst_type may be malbounded.
     }
     String& bound_error_message = String::Handle(zone);
     if (!bound_error.IsNull()) {
       ASSERT(isolate->type_checks());
       bound_error_message = String::New(bound_error.ToErrorCString());
     }
     Exceptions::CreateAndThrowTypeError(location, src_type, dst_type, dst_name,
                                         bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(src_instance, dst_type, instantiator_type_arguments,
-                      Bool::True(), cache);
+                      function_type_arguments, Bool::True(), cache);
   arguments.SetReturn(src_instance);
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
 // Throw assertion error if the object is null. (cf. Boolean Conversion
 // in language Spec.)
 // Arg0: bad object.
 // Return value: none, throws TypeError or AssertionError.
 DEFINE_RUNTIME_ENTRY(NonBoolTypeError, 1) {
@@ skipping 217 matching lines @@
   ASSERT(!result.IsNull() || !FLAG_lazy_dispatchers);
   return result.raw();
 }
 
 
 // Perform the subtype and return constant function based on the result.
 static RawFunction* ComputeTypeCheckTarget(const Instance& receiver,
                                            const AbstractType& type,
                                            const ArgumentsDescriptor& desc) {
   Error& error = Error::Handle();
-  bool result =
-      receiver.IsInstanceOf(type, Object::null_type_arguments(), &error);
+  bool result = receiver.IsInstanceOf(type, Object::null_type_arguments(),
+                                      Object::null_type_arguments(), &error);
   ASSERT(error.IsNull());
   ObjectStore* store = Isolate::Current()->object_store();
   const Function& target =
       Function::Handle(result ? store->simple_instance_of_true_function()
                               : store->simple_instance_of_false_function());
   ASSERT(!target.IsNull());
   return target.raw();
 }
 
 
@@ skipping 1398 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart