Check upper bounds of type arguments when allocating objects of a generic type

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 1607 matching lines @@
 Definition* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   ZoneGrowableArray<Value*>* allocate_arguments =
       new ZoneGrowableArray<Value*>();
   if (requires_type_arguments) {
     BuildConstructorTypeArguments(node, allocate_arguments);
   }
-  BindInstr* allocate =
-      new BindInstr(temp_index(),
-                    new AllocateObjectComp(node,
+  // In checked mode, if the type arguments are uninstantiated, they may need to
+  // be checked against declared bounds at run time.
+  Computation* allocate_comp = NULL;
+  Error& malformed_error = Error::Handle();
+  if (FLAG_enable_type_checks &&
+      requires_type_arguments &&
+      !node->type_arguments().IsNull() &&
+      !node->type_arguments().IsInstantiated() &&
+      !node->type_arguments().IsWithinBoundsOf(cls,
+                                               node->type_arguments(),
+                                               &malformed_error)) {
+    // The uninstantiated type arguments cannot be verified to be within their
+    // bounds at compile time, so verify them at runtime.
+    // Although the type arguments may be uninstantiated at compile time, they
+    // may represent the identity vector and may be replaced by the instantiated
+    // type arguments of the instantiator at run time.
+    allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
+                                                          owner()->try_index(),
+                                                          allocate_arguments);
+  } else {
+    allocate_comp = new AllocateObjectComp(node,
                                            owner()->try_index(),
-                                           allocate_arguments));
+                                           allocate_arguments);
+  }
+  BindInstr* allocate = new BindInstr(temp_index(), allocate_comp);
   AddInstruction(allocate);
   AllocateTempIndex();
   return allocate;
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(ConstructorCallNode* node,
                                               Value* alloc_value) {
   BindInstr* ctor_arg =
       new BindInstr(temp_index(),
@@ skipping 956 matching lines @@
   OS::Print("AllocateObject(%s",
             Class::Handle(comp->constructor().owner()).ToCString());
   for (intptr_t i = 0; i < comp->arguments().length(); i++) {
     OS::Print(", ");
     comp->arguments()[i]->Accept(this);
   }
   OS::Print(")");
 }
 
 
+void FlowGraphPrinter::VisitAllocateObjectWithBoundsCheck(
+    AllocateObjectWithBoundsCheckComp* comp) {
+  OS::Print("AllocateObjectWithBoundsCheck(%s",
+            Class::Handle(comp->constructor().owner()).ToCString());
+  for (intptr_t i = 0; i < comp->arguments().length(); i++) {
+    OS::Print(", ");
+    comp->arguments()[i]->Accept(this);
+  }
+  OS::Print(")");
+}
+
+
 void FlowGraphPrinter::VisitCreateArray(CreateArrayComp* comp) {
   OS::Print("CreateArray(");
   for (int i = 0; i < comp->ElementCount(); ++i) {
     if (i != 0) OS::Print(", ");
     comp->ElementAt(i)->Accept(this);
   }
   OS::Print(")");
 }
 
 
@@ skipping 277 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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