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

runtime/vm/parser.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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 3444 matching lines @@
 
   // The result of ParseMixins() is a chain of super types that is the
   // result of the mixin composition 'S with M1, M2, ...'. The mixin
   // application classes are anonymous (i.e. not registered in the current
   // library). We steal the super type and mixin type from the bottom of
   // the chain and add it to the named mixin application class. The bottom
   // anonymous class in the chain is thrown away.
   const Class& anon_mixin_app_class =
       Class::Handle(mixin_application_type.type_class());
   mixin_application.set_super_type(
-      Type::Handle(anon_mixin_app_class.super_type()));
+      AbstractType::Handle(anon_mixin_app_class.super_type()));
   mixin_application.set_mixin(Type::Handle(anon_mixin_app_class.mixin()));
   const Array& interfaces = Array::Handle(anon_mixin_app_class.interfaces());
   mixin_application.set_interfaces(interfaces);
   AddImplicitConstructor(mixin_application);
 
   if (CurrentToken() == Token::kIMPLEMENTS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = TokenPos();
-    const Type& super_type = Type::Handle(mixin_application.super_type());
+    Type& super_type = Type::Handle();
+    super_type ^= mixin_application.super_type();
     interfaces = ParseInterfaceList(super_type);
     AddInterfaces(interfaces_pos, mixin_application, interfaces);
   }
 
   pending_classes.Add(mixin_application, Heap::kOld);
   ExpectSemicolon();
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
@@ skipping 5840 matching lines @@
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
                                     InvocationMirror::kConstructor,
                                     InvocationMirror::kMethod);
     } else if (constructor.IsRedirectingFactory()) {
       Type& redirect_type = Type::Handle(constructor.RedirectionType());
       if (!redirect_type.IsMalformed() && !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
-        redirect_type ^= redirect_type.InstantiateFrom(type_arguments);
+        Error& malformed_error = Error::Handle();
+        redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
+                                                       &malformed_error);
+        if (!malformed_error.IsNull()) {
+          redirect_type.set_malformed_error(malformed_error);
+        }
       }
       if (redirect_type.IsMalformed()) {
         if (is_const) {
-          const Error& error = Error::Handle(redirect_type.malformed_error());
-          ErrorMsg(error);
+          ErrorMsg(Error::Handle(redirect_type.malformed_error()));
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
       if (FLAG_enable_type_checks && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_arguments = type.arguments();
@@ skipping 713 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart