Simplify generated code for object allocation with type arguments.

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/class_finalizer.h"
@@ skipping 2255 matching lines @@
     Value* type_arguments = NULL;
     if (requires_type_arguments) {
       ASSERT(cls.type_arguments_field_offset() ==
              Closure::type_arguments_offset());
       const Class& instantiator_class = Class::Handle(
           owner()->parsed_function()->function().Owner());
       type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
                                                       instantiator_class,
                                                       NULL);
       arguments->Add(PushArgument(type_arguments));
-
-      Value* instantiator_val = Bind(new ConstantInstr(
-          Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
-      arguments->Add(PushArgument(instantiator_val));
     }
     AllocateObjectInstr* alloc = new AllocateObjectInstr(node->token_pos(),
                                                          cls,
                                                          arguments);
     alloc->set_closure_function(function);
 
     // Create fake fields for function and context. Only the context field is
     // stored at the allocation to be used later when inlining a closure call.
     const Field& function_field =
         Field::ZoneHandle(
@@ skipping 194 matching lines @@
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Value* context = Bind(new CurrentContextInstr());
   Value* clone = Bind(new CloneContextInstr(node->token_pos(), context));
   AddInstruction(new StoreContextInstr(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
-  const bool requires_type_arguments = cls.NumTypeArguments() > 0;
+  const bool cls_is_parameterized = cls.NumTypeArguments() > 0;
 
   ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
-      new ZoneGrowableArray<PushArgumentInstr*>();
-  if (requires_type_arguments) {
-    BuildConstructorTypeArguments(node, allocate_arguments);
+      new ZoneGrowableArray<PushArgumentInstr*>(cls_is_parameterized ? 1 : 0);
+  if (cls_is_parameterized) {
+    Value* type_args = BuildInstantiatedTypeArguments(node->token_pos(),
+                                                      node->type_arguments());
+    allocate_arguments->Add(PushArgument(type_args));
   }
 
   Definition* allocation = new AllocateObjectInstr(
       node->token_pos(),
       Class::ZoneHandle(node->constructor().Owner()),
       allocate_arguments);
 
   return Bind(allocation);
 }
 
@@ skipping 164 matching lines @@
     return Bind(new ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class = Class::ZoneHandle(
       owner()->parsed_function()->function().Owner());
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   const bool use_instantiator_type_args =
       type_arguments.IsUninstantiatedIdentity() ||
       type_arguments.CanShareInstantiatorTypeArguments(instantiator_class);
-  return use_instantiator_type_args
-      ? instantiator_value
-      : Bind(new InstantiateTypeArgumentsInstr(token_pos,
-                                               type_arguments,
-                                               instantiator_class,
-                                               instantiator_value));
+  if (use_instantiator_type_args) {
+    return instantiator_value;
+  } else {
+    return Bind(new InstantiateTypeArgumentsInstr(token_pos,
+                                                  type_arguments,
+                                                  instantiator_class,
+                                                  instantiator_value));
+  }
 }
 
 
-void EffectGraphVisitor::BuildConstructorTypeArguments(
-    ConstructorCallNode* node,
-    ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {
-  const Class& cls = Class::ZoneHandle(node->constructor().Owner());
-  ASSERT((cls.NumTypeArguments() > 0) && !node->constructor().IsFactory());
-  if (node->type_arguments().IsNull() ||
-      node->type_arguments().IsInstantiated()) {
-    Value* type_arguments_val = Bind(new ConstantInstr(node->type_arguments()));
-    call_arguments->Add(PushArgument(type_arguments_val));
-
-    // No instantiator required.
-    Value* instantiator_val = Bind(new ConstantInstr(
-        Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
-    call_arguments->Add(PushArgument(instantiator_val));
-    return;
-  }
-
-  // The type arguments are uninstantiated. We use expression_temp_var to save
-  // the instantiator type arguments because they have two uses.
-  ASSERT(owner()->parsed_function()->expression_temp_var() != NULL);
-  const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function()->function().Owner());
-  Value* type_arguments_val = BuildInstantiatorTypeArguments(
-      node->token_pos(), instantiator_class, NULL);
-
-  const bool use_instantiator_type_args =
-      node->type_arguments().IsUninstantiatedIdentity() ||
-      node->type_arguments().CanShareInstantiatorTypeArguments(
-          instantiator_class);
-
-  if (!use_instantiator_type_args) {
-    const intptr_t len = node->type_arguments().Length();
-    if (node->type_arguments().IsRawInstantiatedRaw(len)) {
-      type_arguments_val =
-          Bind(BuildStoreExprTemp(type_arguments_val));
-      type_arguments_val = Bind(
-          new ExtractConstructorTypeArgumentsInstr(
-              node->token_pos(),
-              node->type_arguments(),
-              instantiator_class,
-              type_arguments_val));
-    } else {
-      Do(BuildStoreExprTemp(type_arguments_val));
-      type_arguments_val = Bind(new ConstantInstr(node->type_arguments()));
-    }
-  }
-  call_arguments->Add(PushArgument(type_arguments_val));
-
-  Value* instantiator_val = NULL;
-  if (!use_instantiator_type_args) {
-    instantiator_val = Bind(BuildLoadExprTemp());
-    const intptr_t len = node->type_arguments().Length();
-    if (node->type_arguments().IsRawInstantiatedRaw(len)) {
-      instantiator_val =
-          Bind(new ExtractConstructorInstantiatorInstr(node,
-                                                       instantiator_class,
-                                                       instantiator_val));
-    }
-  } else {
-    // No instantiator required.
-    instantiator_val = Bind(new ConstantInstr(
-        Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
-  }
-  call_arguments->Add(PushArgument(instantiator_val));
-}
-
-
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
@@ skipping 1235 matching lines @@
                                   LanguageError::kError,
                                   Heap::kNew,
                                   "FlowGraphBuilder Bailout: %s %s",
                                   String::Handle(function.name()).ToCString(),
                                   reason));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart