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

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 1216 matching lines @@
   }
   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)) {
-    // TODO(regis): function_type_arguments = BuildNullValue((token_pos);
+    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
 // destination type is dynamic or if the compile type of the value is a subtype
@@ skipping 208 matching lines @@
     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)) {
-    // TODO(regis): function_type_arguments = BuildNullValue(token_pos);
+    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 48 matching lines @@
         kNumArgsChecked, owner()->ic_data_array());
     if (negate_result) {
       result = new (Z) BooleanNegateInstr(Bind(result));
     }
     ReturnDefinition(result);
     return;
   }
 
   PushArgumentInstr* push_instantiator_type_args =
       PushInstantiatorTypeArguments(type, node->token_pos());
-  // TODO(regis): PushArgumentInstr* push_function_type_args =
-  //    PushFunctionTypeArguments(type, node->token_pos());
+  PushArgumentInstr* push_function_type_args =
+      PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(4);
   arguments->Add(push_left);
   arguments->Add(push_instantiator_type_args);
-  // TODO(regis): arguments->Add(push_function_type_args);
+  arguments->Add(push_function_type_args);
   Value* type_const = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_const));
   const intptr_t kNumArgsChecked = 1;
   Definition* result = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(), arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array());
   if (negate_result) {
     result = new (Z) BooleanNegateInstr(Bind(result));
@@ skipping 11 matching lines @@
   node->left()->Visit(&for_value);
   Append(for_value);
   if (CanSkipTypeCheck(node->token_pos(), for_value.value(), type,
                        Symbols::InTypeCast())) {
     ReturnValue(for_value.value());
     return;
   }
   PushArgumentInstr* push_left = PushArgument(for_value.value());
   PushArgumentInstr* push_instantiator_type_args =
       PushInstantiatorTypeArguments(type, node->token_pos());
-  // TODO(regis): PushArgumentInstr* push_function_type_args =
-  //    PushFunctionTypeArguments(type, node->token_pos());
+  PushArgumentInstr* push_function_type_args =
+      PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(4);
   arguments->Add(push_left);
   arguments->Add(push_instantiator_type_args);
-  // TODO(regis): arguments->Add(push_function_type_args);
+  arguments->Add(push_function_type_args);
   Value* type_arg = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_as()),
       node->kind(), arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
@@ skipping 1141 matching lines @@
       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* function_type_args = NULL;
   if (type_arguments.IsInstantiated(kCurrentFunction)) {
-    // TODO(regis): function_type_args = BuildNullValue(token_pos);
+    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));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
@@ skipping 1381 matching lines @@
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     TokenPosition token_pos,
     const Class& function_class,
     const String& function_name,
     ArgumentListNode* function_arguments,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>();
   // Object receiver, actually a class literal of the unresolved method's owner.
   AbstractType& type = Type::ZoneHandle(
-      Z,
-      Type::New(function_class, TypeArguments::Handle(Z, TypeArguments::null()),
-                token_pos, Heap::kOld));
+      Z, Type::New(function_class, Object::null_type_arguments(), token_pos,
+                   Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(function_class, type);
   Value* receiver_value = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(receiver_value));
   // String memberName.
   const String& member_name =
       String::ZoneHandle(Z, Symbols::New(T, function_name));
   Value* member_name_value = Bind(new (Z) ConstantInstr(member_name));
   arguments->Add(PushArgument(member_name_value));
   // Smi invocation_type.
   Value* invocation_type_value = Bind(
@@ skipping 196 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