Complete implementation of bounds checking in the vm, by introducing a vm object

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 1044 matching lines @@
     const Instance& literal_value = node->left()->AsLiteralNode()->literal();
     const Class& cls = Class::Handle(literal_value.clazz());
     ConstantInstr* result = NULL;
     if (cls.IsNullClass()) {
       // A null object is only an instance of Object and dynamic, which has
       // already been checked above (if the type is instantiated). So we can
       // return false here if the instance is null (and if the type is
       // instantiated).
       result = new ConstantInstr(negate_result ? Bool::True() : Bool::False());
     } else {
-      if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
+      Error& malformed_error = Error::Handle();
+      if (literal_value.IsInstanceOf(type,
+                                     TypeArguments::Handle(),
+                                     &malformed_error)) {
         result = new ConstantInstr(negate_result ?
                                    Bool::False() : Bool::True());
       } else {
         result = new ConstantInstr(negate_result ?
                                    Bool::True() : Bool::False());
       }
+      ASSERT(malformed_error.IsNull());
     }
     ReturnDefinition(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   PushArgumentInstr* push_instantiator = NULL;
@@ skipping 838 matching lines @@
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
   Definition* allocate_comp = NULL;
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
-      !node->type_arguments().IsWithinBoundsOf(cls,
-                                               node->type_arguments(),
-                                               NULL)) {
+      node->type_arguments().IsBounded()) {
     Value* type_arguments = NULL;
     Value* instantiator = NULL;
     BuildConstructorTypeArguments(node, &type_arguments, &instantiator, NULL);
 
     // 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 AllocateObjectWithBoundsCheckInstr(node,
                                                            type_arguments,
                                                            instantiator);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
 
     if (requires_type_arguments) {
       BuildConstructorTypeArguments(node, NULL, NULL, allocate_arguments);
     }
@@ skipping 1339 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