Implement eager instantiation and canonicalization of type arguments at run

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 2151 matching lines @@
   if (num_temps > 0) {
     owner()->DeallocateTemps(num_temps);
     ReturnDefinition(new DropTempsInstr(num_temps, result_value));
   } else {
     ReturnValue(result_value);
   }
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  const AbstractTypeArguments& type_args =
-      AbstractTypeArguments::ZoneHandle(node->type().arguments());
+  const TypeArguments& type_args =
+      TypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   Value* num_elements =
       Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(node->length()))));
   CreateArrayInstr* create = new CreateArrayInstr(node->token_pos(),
                                                   element_type,
                                                   num_elements);
   Value* array_val = Bind(create);
 
   { LocalVariable* tmp_var = EnterTempLocalScope(array_val);
@@ skipping 298 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) {
+Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.NumTypeArguments() > 0;
 
-  // In checked mode, if the type arguments are uninstantiated, they may need to
-  // be checked against declared bounds at run time.
-  Definition* allocation = NULL;
-  if (FLAG_enable_type_checks &&
-      requires_type_arguments &&
-      !node->type_arguments().IsNull() &&
-      !node->type_arguments().IsInstantiated() &&
-      node->type_arguments().IsBounded()) {
-    ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
-        new ZoneGrowableArray<PushArgumentInstr*>(4);
-    // Argument 1: Empty argument slot for return value.
-    Value* null_val = Bind(new ConstantInstr(Object::ZoneHandle()));
-    allocate_arguments->Add(PushArgument(null_val));
-    // Argument 2: Class.
-    Value* cls_val =
-        Bind(new ConstantInstr(Class::ZoneHandle(node->constructor().Owner())));
-    allocate_arguments->Add(PushArgument(cls_val));
-    // Build arguments 3 and 4.
+  ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>();
+  if (requires_type_arguments) {
     BuildConstructorTypeArguments(node, allocate_arguments);
+  }
 
-    // The uninstantiated type arguments cannot be verified to be within their
-    // bounds at compile time, so verify them at runtime.
-    allocation = new AllocateObjectWithBoundsCheckInstr(node);
-  } else {
-    ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
-        new ZoneGrowableArray<PushArgumentInstr*>();
-    if (requires_type_arguments) {
-      BuildConstructorTypeArguments(node, allocate_arguments);
-    }
+  Definition* allocation = new AllocateObjectInstr(
+      node->token_pos(),
+      Class::ZoneHandle(node->constructor().Owner()),
+      allocate_arguments);
 
-    allocation = new AllocateObjectInstr(
-        node->token_pos(),
-        Class::ZoneHandle(node->constructor().Owner()),
-        allocate_arguments);
-  }
   return Bind(allocation);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
       new ConstantInstr(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
@@ skipping 100 matching lines @@
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     intptr_t token_pos,
     const Class& instantiator_class,
     Value* instantiator) {
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
-    AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
+    TypeArguments& type_arguments = TypeArguments::ZoneHandle();
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalize);
     ASSERT(!type.IsMalformedOrMalbounded());
     type_arguments = type.arguments();
     type_arguments = type_arguments.Canonicalize();
     return Bind(new ConstantInstr(type_arguments));
   }
   Function& outer_function =
       Function::Handle(owner()->parsed_function()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // No instantiator for factories.
     ASSERT(instantiator == NULL);
     ASSERT(owner()->parsed_function()->instantiator() != NULL);
     ValueGraphVisitor for_instantiator(owner());
     owner()->parsed_function()->instantiator()->Visit(&for_instantiator);
     Append(for_instantiator);
     return for_instantiator.value();
   }
   if (instantiator == NULL) {
     instantiator = BuildInstantiator();
   }
   // The instantiator is the receiver of the caller, which is not a factory.
-  // The receiver cannot be null; extract its AbstractTypeArguments object.
+  // The receiver cannot be null; extract its TypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
-  // of the factory, i.e. already an AbstractTypeArguments object.
+  // of the factory, i.e. already a TypeArguments object.
   intptr_t type_arguments_field_offset =
       instantiator_class.type_arguments_field_offset();
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new LoadFieldInstr(
       instantiator,
       type_arguments_field_offset,
       Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
-    const AbstractTypeArguments& type_arguments) {
+    const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     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() ||
@@ skipping 1322 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