Pass type argument vector to generic functions (if --reify-generic-functions is

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 1122 matching lines @@
   }
 
   if (FLAG_causal_async_stacks &&
       (function.IsAsyncClosure() || function.IsAsyncGenClosure())) {
     // We are returning from an asynchronous closure. Before we do that, be
     // sure to clear the thread's asynchronous stack trace.
     const Function& async_clear_thread_stack_trace = Function::ZoneHandle(
         Z, isolate()->object_store()->async_clear_thread_stack_trace());
     ZoneGrowableArray<PushArgumentInstr*>* no_arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(0);
-    StaticCallInstr* call_async_clear_thread_stack_trace = new (Z)
-        StaticCallInstr(node->token_pos().ToSynthetic(),
-                        async_clear_thread_stack_trace, Object::null_array(),
-                        no_arguments, owner()->ic_data_array());
+    const int kTypeArgsLen = 0;
+    StaticCallInstr* call_async_clear_thread_stack_trace =
+        new (Z) StaticCallInstr(node->token_pos().ToSynthetic(),
+                                async_clear_thread_stack_trace, kTypeArgsLen,
+                                Object::null_array(), no_arguments,
+                                owner()->ic_data_array());
     Do(call_async_clear_thread_stack_trace);
   }
 
   // Async functions contain two types of return statements:
   // 1) Returns that should complete the completer once all finally blocks have
   //    been inlined (call: :async_completer.complete(return_value)). These
   //    returns end up returning null in the end.
   // 2) "Continuation" returns that should not complete the completer but return
   //    the value.
   //
@@ skipping 11 matching lines @@
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
     Value* rcv_value = Bind(BuildLoadLocal(*rcv_var, node->token_pos()));
     arguments->Add(PushArgument(rcv_value));
     Value* returned_value = Bind(BuildLoadExprTemp(node->token_pos()));
     arguments->Add(PushArgument(returned_value));
     // Call a helper function to complete the completer. The debugger
     // uses the helper function to know when to step-out.
     const Function& complete_on_async_return = Function::ZoneHandle(
         Z, isolate()->object_store()->complete_on_async_return());
     ASSERT(!complete_on_async_return.IsNull());
+    const int kTypeArgsLen = 0;
     StaticCallInstr* call = new (Z) StaticCallInstr(
-        node->token_pos().ToSynthetic(), complete_on_async_return,
+        node->token_pos().ToSynthetic(), complete_on_async_return, kTypeArgsLen,
         Object::null_array(), arguments, owner()->ic_data_array());
     Do(call);
 
     // Rebind the return value for the actual return call to be null.
     return_value = BuildNullValue(node->token_pos());
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (HasContextScope()) {
@@ skipping 166 matching lines @@
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = Symbols::Token(node->kind());
+  const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
-      node->token_pos(), name, node->kind(), arguments, Object::null_array(),
-      kNumArgsChecked, owner()->ic_data_array());
+      node->token_pos(), name, node->kind(), arguments, kTypeArgsLen,
+      Object::null_array(), kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
@@ skipping 137 matching lines @@
 
   // We now know type is a real class (!num, !int, !smi, !string)
   // and the type check could NOT be removed at compile time.
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   if (FlowGraphBuilder::SimpleInstanceOfType(type)) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
     arguments->Add(push_left);
     Value* type_const = Bind(new (Z) ConstantInstr(type));
     arguments->Add(PushArgument(type_const));
+    const intptr_t kTypeArgsLen = 0;
     const intptr_t kNumArgsChecked = 2;
     Definition* result = new (Z) InstanceCallInstr(
         node->token_pos(),
         Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()), node->kind(),
-        arguments,
+        arguments, kTypeArgsLen,
         Object::null_array(),  // No argument names.
         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());
   PushArgumentInstr* push_function_type_args =
       PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(4);
   arguments->Add(push_left);
   arguments->Add(push_instantiator_type_args);
   arguments->Add(push_function_type_args);
   Value* type_const = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_const));
+  const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;
   Definition* result = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_instanceOf()),
-      node->kind(), arguments,
+      node->kind(), arguments, kTypeArgsLen,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array());
   if (negate_result) {
     result = new (Z) BooleanNegateInstr(Bind(result));
   }
   ReturnDefinition(result);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
@@ skipping 14 matching lines @@
       PushInstantiatorTypeArguments(type, node->token_pos());
   PushArgumentInstr* push_function_type_args =
       PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(4);
   arguments->Add(push_left);
   arguments->Add(push_instantiator_type_args);
   arguments->Add(push_function_type_args);
   Value* type_arg = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_arg));
+  const int kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_as()),
-      node->kind(), arguments,
+      node->kind(), arguments, kTypeArgsLen,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 StrictCompareInstr* EffectGraphVisitor::BuildStrictCompare(
     AstNode* left,
     AstNode* right,
     Token::Kind kind,
@@ skipping 53 matching lines @@
     Append(for_left_value);
     PushArgumentInstr* push_left = PushArgument(for_left_value.value());
     arguments->Add(push_left);
 
     ValueGraphVisitor for_right_value(owner());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     PushArgumentInstr* push_right = PushArgument(for_right_value.value());
     arguments->Add(push_right);
 
+    const intptr_t kTypeArgsLen = 0;
     const intptr_t kNumArgsChecked = 2;
     Definition* result = new (Z)
         InstanceCallInstr(node->token_pos(), Symbols::EqualOperator(),
                           Token::kEQ,  // Result is negated later for kNE.
-                          arguments, Object::null_array(), kNumArgsChecked,
-                          owner()->ic_data_array());
+                          arguments, kTypeArgsLen, Object::null_array(),
+                          kNumArgsChecked, owner()->ic_data_array());
     if (node->kind() == Token::kNE) {
       Isolate* isolate = Isolate::Current();
       if (isolate->type_checks() || isolate->asserts()) {
         Value* value = Bind(result);
         result = new (Z) AssertBooleanInstr(node->token_pos(), value);
       }
       Value* value = Bind(result);
       result = new (Z) BooleanNegateInstr(value);
     }
     ReturnDefinition(result);
     return;
   }
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
 
   ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   arguments->Add(push_left);
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
   arguments->Add(push_right);
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
+  const intptr_t kTypeArgsLen = 0;
   InstanceCallInstr* comp = new (Z) InstanceCallInstr(
       node->token_pos(), Symbols::Token(node->kind()), node->kind(), arguments,
-      Object::null_array(), 2, owner()->ic_data_array());
+      kTypeArgsLen, Object::null_array(), 2, owner()->ic_data_array());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     Isolate* isolate = Isolate::Current();
     if (isolate->type_checks() || isolate->asserts()) {
       value =
           Bind(new (Z) AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new (Z) BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
+  const intptr_t kTypeArgsLen = 0;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Symbols::Token(node->kind()), node->kind(), arguments,
-      Object::null_array(), 1, owner()->ic_data_array());
+      kTypeArgsLen, Object::null_array(), 1, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner());
@@ skipping 526 matching lines @@
     StringInterpolateNode* node) {
   ValueGraphVisitor for_argument(owner());
   ArrayNode* arguments = node->value();
   if (arguments->length() == 1) {
     ZoneGrowableArray<PushArgumentInstr*>* values =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->ElementAt(0)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
+    const int kTypeArgsLen = 0;
     const int kNumberOfArguments = 1;
     const Array& kNoArgumentNames = Object::null_array();
     const Class& cls =
         Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
     ASSERT(!cls.IsNull());
     const Function& function = Function::ZoneHandle(
         Z, Resolver::ResolveStatic(
                cls, Library::PrivateCoreLibName(Symbols::InterpolateSingle()),
-               kNumberOfArguments, kNoArgumentNames));
-    StaticCallInstr* call =
-        new (Z) StaticCallInstr(node->token_pos(), function, kNoArgumentNames,
-                                values, owner()->ic_data_array());
+               kTypeArgsLen, kNumberOfArguments, kNoArgumentNames));
+    StaticCallInstr* call = new (Z)
+        StaticCallInstr(node->token_pos(), function, kTypeArgsLen,
+                        kNoArgumentNames, values, owner()->ic_data_array());
     ReturnDefinition(call);
     return;
   }
   arguments->Visit(&for_argument);
   Append(for_argument);
   StringInterpolateInstr* instr =
       new (Z) StringInterpolateInstr(for_argument.value(), node->token_pos());
   ReturnDefinition(instr);
 }
 
@@ skipping 110 matching lines @@
       Value* context = Bind(BuildCurrentContext(node->token_pos()));
       Do(new (Z) StoreInstanceFieldInstr(Closure::context_offset(),
                                          closure_tmp_val, context,
                                          kEmitStoreBarrier, node->token_pos()));
     }
     ReturnDefinition(ExitTempLocalScope(closure_val));
   }
 }
 
 
+void EffectGraphVisitor::BuildPushTypeArguments(
+    const ArgumentListNode& node,
+    ZoneGrowableArray<PushArgumentInstr*>* values) {
+  if (node.type_args_len() > 0) {
+    Value* type_args_val;
+    if (node.type_args_var() != NULL) {
+      type_args_val =
+          Bind(new (Z) LoadLocalInstr(*node.type_args_var(), node.token_pos()));
+    } else {
+      const TypeArguments& type_args = node.type_arguments();
+      ASSERT(!type_args.IsNull() &&
+             (type_args.Length() == node.type_args_len()));
+      type_args_val =
+          BuildInstantiatedTypeArguments(node.token_pos(), type_args);
+    }
+    PushArgumentInstr* push_type_args = PushArgument(type_args_val);
+    values->Add(push_type_args);
+  }
+}
+
+
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
@@ skipping 37 matching lines @@
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceCallConditional(node);
     ReturnDefinition(BuildLoadExprTemp(node->token_pos()));
   } else {
     EffectGraphVisitor::VisitInstanceCallNode(node);
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  ValueGraphVisitor for_receiver(owner());
-  node->receiver()->Visit(&for_receiver);
-  Append(for_receiver);
   if (node->is_conditional()) {
+    ValueGraphVisitor for_receiver(owner());
+    node->receiver()->Visit(&for_receiver);
+    Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceCallConditional(node);
   } else {
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new (Z) ZoneGrowableArray<PushArgumentInstr*>(
+            node->arguments()->LengthWithTypeArgs() + 1);
+    BuildPushTypeArguments(*node->arguments(), arguments);
+    ValueGraphVisitor for_receiver(owner());
+    node->receiver()->Visit(&for_receiver);
+    Append(for_receiver);
     PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
-    ZoneGrowableArray<PushArgumentInstr*>* arguments = new (Z)
-        ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length() + 1);
     arguments->Add(push_receiver);
-
     BuildPushArguments(*node->arguments(), arguments);
     InstanceCallInstr* call = new (Z) InstanceCallInstr(
         node->token_pos(), node->function_name(), Token::kILLEGAL, arguments,
-        node->arguments()->names(), 1, owner()->ic_data_array());
+        node->arguments()->type_args_len(), node->arguments()->names(), 1,
+        owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  ZoneGrowableArray<PushArgumentInstr*>* arguments = new (Z)
-      ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(
+          node->arguments()->LengthWithTypeArgs());
+  BuildPushTypeArguments(*node->arguments(), arguments);
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call = new (Z) StaticCallInstr(
-      node->token_pos(), node->function(), node->arguments()->names(),
-      arguments, owner()->ic_data_array());
+      node->token_pos(), node->function(), node->arguments()->type_args_len(),
+      node->arguments()->names(), arguments, owner()->ic_data_array());
   if (node->function().recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(node->function()));
   }
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildClosureCall(ClosureCallNode* node,
                                           bool result_needed) {
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(
+          node->arguments()->LengthWithTypeArgs() + 1);
+  BuildPushTypeArguments(*node->arguments(), arguments);
+
   ValueGraphVisitor for_closure(owner());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
-
   Value* closure_value = for_closure.value();
   LocalVariable* tmp_var = EnterTempLocalScope(closure_value);
 
-  ZoneGrowableArray<PushArgumentInstr*>* arguments = new (Z)
-      ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   Value* closure_val =
       Bind(new (Z) LoadLocalInstr(*tmp_var, node->token_pos()));
   PushArgumentInstr* push_closure = PushArgument(closure_val);
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   closure_val = Bind(new (Z) LoadLocalInstr(*tmp_var, node->token_pos()));
   LoadFieldInstr* function_load = new (Z) LoadFieldInstr(
       closure_val, Closure::function_offset(),
       AbstractType::ZoneHandle(Z, AbstractType::null()), node->token_pos());
@@ skipping 57 matching lines @@
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
 
   BuildPushArguments(*node->arguments(), arguments);
+  const intptr_t kTypeArgsLen = 0;
   Do(new (Z) StaticCallInstr(node->token_pos(), node->constructor(),
-                             node->arguments()->names(), arguments,
-                             owner()->ic_data_array()));
+                             kTypeArgsLen, node->arguments()->names(),
+                             arguments, owner()->ic_data_array()));
 }
 
 
 static intptr_t GetResultCidOfListFactory(ConstructorCallNode* node) {
   const Function& function = node->constructor();
   const Class& function_class = Class::Handle(function.Owner());
 
   if ((function_class.library() != Library::CoreLibrary()) &&
       (function_class.library() != Library::TypedDataLibrary())) {
     return kDynamicCid;
@@ skipping 17 matching lines @@
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments =
         PushArgument(BuildInstantiatedTypeArguments(node->token_pos(),
                                                     node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
+    const int kTypeArgsLen = 0;
     StaticCallInstr* call = new (Z) StaticCallInstr(
-        node->token_pos(), node->constructor(), node->arguments()->names(),
-        arguments, owner()->ic_data_array());
+        node->token_pos(), node->constructor(), kTypeArgsLen,
+        node->arguments()->names(), arguments, owner()->ic_data_array());
     const intptr_t result_cid = GetResultCidOfListFactory(node);
     if (result_cid != kDynamicCid) {
       call->set_result_cid(result_cid);
       call->set_is_known_list_constructor(true);
       // Recognized fixed length array factory must have two arguments:
       // (0) type-arguments, (1) length.
       ASSERT(!LoadFieldInstr::IsFixedLengthArrayCid(result_cid) ||
              arguments->length() == 2);
     } else if (node->constructor().recognized_kind() !=
                MethodRecognizer::kUnknown) {
@@ skipping 209 matching lines @@
   if (node->is_conditional()) {
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceGetterConditional(node);
   } else {
     PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->Add(push_receiver);
     const String& name =
         String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
-    InstanceCallInstr* call = new (Z)
-        InstanceCallInstr(node->token_pos(), name, Token::kGET, arguments,
-                          Object::null_array(), 1, owner()->ic_data_array());
+    const intptr_t kTypeArgsLen = 0;
+    InstanceCallInstr* call = new (Z) InstanceCallInstr(
+        node->token_pos(), name, Token::kGET, arguments, kTypeArgsLen,
+        Object::null_array(), 1, owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   ValueGraphVisitor for_receiver(owner());
@@ skipping 39 matching lines @@
         token_pos, load_temp, node->field_name(), node->value());
     setter->Visit(&for_false);
     Join(for_test, for_true, for_false);
     return;
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
+  const int kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
-      token_pos, name, Token::kSET, arguments, Object::null_array(),
-      kNumArgsChecked, owner()->ic_data_array());
+      token_pos, name, Token::kSET, arguments, kTypeArgsLen,
+      Object::null_array(), kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   const TokenPosition token_pos = node->token_pos();
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
@@ skipping 20 matching lines @@
 
     Join(for_test, for_true, for_false);
     ReturnDefinition(BuildLoadExprTemp(token_pos));
     return;
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
+  const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   Do(new (Z) InstanceCallInstr(token_pos, name, Token::kSET, arguments,
-                               Object::null_array(), kNumArgsChecked,
-                               owner()->ic_data_array()));
+                               kTypeArgsLen, Object::null_array(),
+                               kNumArgsChecked, owner()->ic_data_array()));
   ReturnDefinition(BuildLoadExprTemp(token_pos));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle(Z, Function::null());
@@ skipping 41 matching lines @@
           NULL,  // No Arguments to getter.
           InvocationMirror::EncodeType(node->cls().IsTopLevel()
                                            ? InvocationMirror::kTopLevel
                                            : InvocationMirror::kStatic,
                                        InvocationMirror::kGetter));
       ReturnDefinition(call);
       return;
     }
   }
   ASSERT(!getter_function.IsNull());
+  const intptr_t kTypeArgsLen = 0;
   StaticCallInstr* call =
-      new (Z) StaticCallInstr(node->token_pos(), getter_function,
+      new (Z) StaticCallInstr(node->token_pos(), getter_function, kTypeArgsLen,
                               Object::null_array(),  // No names
                               arguments, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
@@ skipping 40 matching lines @@
     ValueGraphVisitor for_value(owner());
     node->value()->Visit(&for_value);
     Append(for_value);
     Value* value = NULL;
     if (result_is_needed) {
       value = Bind(BuildStoreExprTemp(for_value.value(), token_pos));
     } else {
       value = for_value.value();
     }
     arguments->Add(PushArgument(value));
-
-    call = new (Z) StaticCallInstr(token_pos, setter_function,
+    const intptr_t kTypeArgsLen = 0;
+    call = new (Z) StaticCallInstr(token_pos, setter_function, kTypeArgsLen,
                                    Object::null_array(),  // No names.
                                    arguments, owner()->ic_data_array());
   }
   if (result_is_needed) {
     Do(call);
     ReturnDefinition(BuildLoadExprTemp(token_pos));
   } else {
     ReturnDefinition(call);
   }
 }
@@ skipping 425 matching lines @@
   ValueGraphVisitor for_array(owner());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
+  const intptr_t kTypeArgsLen = 0;
   if (super_function != NULL) {
     // Generate static call to super operator.
     StaticCallInstr* load = new (Z) StaticCallInstr(
-        node->token_pos(), *super_function, Object::null_array(), arguments,
-        owner()->ic_data_array());
+        node->token_pos(), *super_function, kTypeArgsLen, Object::null_array(),
+        arguments, owner()->ic_data_array());
     ReturnDefinition(load);
   } else {
     // Generate dynamic call to index operator.
     const intptr_t checked_argument_count = 1;
     InstanceCallInstr* load = new (Z) InstanceCallInstr(
         node->token_pos(), Symbols::IndexToken(), Token::kINDEX, arguments,
-        Object::null_array(), checked_argument_count, owner()->ic_data_array());
+        kTypeArgsLen, Object::null_array(), checked_argument_count,
+        owner()->ic_data_array());
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(StoreIndexedNode* node,
                                                         bool result_is_needed) {
   Function* super_function = NULL;
   const TokenPosition token_pos = node->token_pos();
   if (node->IsSuperStore()) {
@@ skipping 39 matching lines @@
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value(), token_pos));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
+  const intptr_t kTypeArgsLen = 0;
   if (super_function != NULL) {
     // Generate static call to super operator []=.
 
-    StaticCallInstr* store = new (Z)
-        StaticCallInstr(token_pos, *super_function, Object::null_array(),
-                        arguments, owner()->ic_data_array());
+    StaticCallInstr* store = new (Z) StaticCallInstr(
+        token_pos, *super_function, kTypeArgsLen, Object::null_array(),
+        arguments, owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
     }
   } else {
     // Generate dynamic call to operator []=.
     const intptr_t checked_argument_count = 2;  // Do not check for value type.
     InstanceCallInstr* store = new (Z) InstanceCallInstr(
         token_pos, Symbols::AssignIndexToken(), Token::kASSIGN_INDEX, arguments,
-        Object::null_array(), checked_argument_count, owner()->ic_data_array());
+        kTypeArgsLen, Object::null_array(), checked_argument_count,
+        owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
     }
   }
 }
 
 
@@ skipping 149 matching lines @@
         *async_stack_trace_var, node->token_pos().ToSynthetic()));
     // Setup arguments for _asyncSetThreadStackTrace.
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->Add(PushArgument(async_stack_trace_value));
 
     const Function& async_set_thread_stack_trace = Function::ZoneHandle(
         Z, isolate()->object_store()->async_set_thread_stack_trace());
     ASSERT(!async_set_thread_stack_trace.IsNull());
     // Call _asyncSetThreadStackTrace
-    StaticCallInstr* call_async_set_thread_stack_trace = new (Z)
-        StaticCallInstr(node->token_pos().ToSynthetic(),
-                        async_set_thread_stack_trace, Object::null_array(),
-                        arguments, owner()->ic_data_array());
+    const intptr_t kTypeArgsLen = 0;
+    StaticCallInstr* call_async_set_thread_stack_trace =
+        new (Z) StaticCallInstr(node->token_pos().ToSynthetic(),
+                                async_set_thread_stack_trace, kTypeArgsLen,
+                                Object::null_array(), arguments,
+                                owner()->ic_data_array());
     Do(call_async_set_thread_stack_trace);
   }
 
 
   if (FLAG_support_debugger && is_top_level_sequence &&
       function.is_debuggable()) {
     // Place a debug check at method entry to ensure breaking on a method always
     // happens, even if there are no assignments/calls/runtimecalls in the first
     // basic block. Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
@@ skipping 313 matching lines @@
     bool is_super_invocation) {
   TokenPosition args_pos = method_arguments->token_pos();
   LocalVariable* temp = NULL;
   if (save_last_arg) {
     temp = owner()->parsed_function().expression_temp_var();
   }
   ArgumentListNode* args = Parser::BuildNoSuchMethodArguments(
       args_pos, method_name, *method_arguments, temp, is_super_invocation);
   // Make sure we resolve to a compatible noSuchMethod, otherwise call
   // noSuchMethod of class Object.
+  const int kTypeArgsLen = 0;
   const int kNumArguments = 2;
-  ArgumentsDescriptor args_desc(
-      Array::ZoneHandle(Z, ArgumentsDescriptor::New(kNumArguments)));
+  ArgumentsDescriptor args_desc(Array::ZoneHandle(
+      Z, ArgumentsDescriptor::New(kTypeArgsLen, kNumArguments)));
   Function& no_such_method_func = Function::ZoneHandle(
       Z, Resolver::ResolveDynamicForReceiverClass(
              target_class, Symbols::NoSuchMethod(), args_desc));
   if (no_such_method_func.IsNull()) {
     const Class& object_class =
         Class::ZoneHandle(Z, isolate()->object_store()->object_class());
     no_such_method_func = Resolver::ResolveDynamicForReceiverClass(
         object_class, Symbols::NoSuchMethod(), args_desc);
   }
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildPushArguments(*args, push_arguments);
-  return new (Z)
-      StaticCallInstr(args_pos, no_such_method_func, Object::null_array(),
-                      push_arguments, owner()->ic_data_array());
+  return new (Z) StaticCallInstr(args_pos, no_such_method_func, kTypeArgsLen,
+                                 Object::null_array(), push_arguments,
+                                 owner()->ic_data_array());
 }
 
 
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     TokenPosition token_pos,
     const Class& function_class,
     const String& function_name,
     ArgumentListNode* function_arguments,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
@@ skipping 37 matching lines @@
 
   // List existingArgumentNames.
   Value* existing_argument_names_value =
       Bind(new (Z) ConstantInstr(Array::ZoneHandle(Z, Array::null())));
   arguments->Add(PushArgument(existing_argument_names_value));
   // Resolve and call NoSuchMethodError._throwNew.
   const Library& core_lib = Library::Handle(Z, Library::CoreLibrary());
   const Class& cls =
       Class::Handle(Z, core_lib.LookupClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
+  const intptr_t kTypeArgsLen = 0;
   const Function& func = Function::ZoneHandle(
       Z, Resolver::ResolveStatic(
              cls, Library::PrivateCoreLibName(Symbols::ThrowNew()),
-             arguments->length(), Object::null_array()));
+             kTypeArgsLen, arguments->length(), Object::null_array()));
   ASSERT(!func.IsNull());
-  return new (Z) StaticCallInstr(token_pos, func,
+  return new (Z) StaticCallInstr(token_pos, func, kTypeArgsLen,
                                  Object::null_array(),  // No names.
                                  arguments, owner()->ic_data_array());
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   if (FLAG_support_debugger) {
     if (node->exception()->IsLiteralNode() ||
         node->exception()->IsLoadLocalNode() ||
         node->exception()->IsLoadStaticFieldNode() ||
@@ skipping 148 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