Further improve and simplify IL for building constructor 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/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 2265 matching lines @@
       *instantiator = instantiator_val;
     }
     return;
   }
   // The type arguments are uninstantiated. We use expression_temp_var to save
   // the instantiator type arguments becuase they have two uses.
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& temp = *owner()->parsed_function().expression_temp_var();
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
-  Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
+  Value* type_arguments_val = BuildInstantiatorTypeArguments(
       node->token_pos(), instantiator_class, NULL);
-  Value* stored_instantiator =
-      Bind(BuildStoreTemp(temp, instantiator_type_arguments));
 
-  Value* type_arguments_val = Bind(
-      new ExtractConstructorTypeArgumentsInstr(
-          node->token_pos(),
-          node->type_arguments(),
-          instantiator_class,
-          stored_instantiator));
+  const bool use_instantiator_type_args =
+      node->type_arguments().IsUninstantiatedIdentity() ||
+      node->type_arguments().CanShareInstantiatorTypeArguments(
+          instantiator_class);
+
+  if (!use_instantiator_type_args) {
+    type_arguments_val =
+        Bind(BuildStoreTemp(temp, type_arguments_val));
+    type_arguments_val = Bind(
+        new ExtractConstructorTypeArgumentsInstr(
+            node->token_pos(),
+            node->type_arguments(),
+            instantiator_class,
+            type_arguments_val));
+  }
 
   if (call_arguments != NULL) {
     ASSERT(type_arguments == NULL);
     call_arguments->Add(PushArgument(type_arguments_val));
   } else {
     ASSERT(type_arguments != NULL);
     *type_arguments = type_arguments_val;
   }
 
-  Value* load_instantiator = Bind(BuildLoadLocal(temp));
-  Value* instantiator_val =
-      Bind(new ExtractConstructorInstantiatorInstr(node,
-                                                   instantiator_class,
-                                                   load_instantiator));
+  Value* instantiator_val = NULL;
+  if (!use_instantiator_type_args) {
+    instantiator_val = Bind(BuildLoadLocal(temp));
+    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))));
+  }
 
   if (call_arguments != NULL) {
     ASSERT(instantiator == NULL);
     call_arguments->Add(PushArgument(instantiator_val));
   } else {
     ASSERT(instantiator != NULL);
     *instantiator = instantiator_val;
   }
 }
 
@@ skipping 1054 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart