Allows turning on checked mode on a per-isolate basis

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 5852 matching lines @@
 const char* Function::ToQualifiedCString() const {
   char* chars = NULL;
   ConstructFunctionFullyQualifiedCString(*this, &chars, 0, false,
                                          kQualifiedFunctionLibKindLibUrl);
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
                                            Error* bound_error) const {
-  ASSERT(FLAG_error_on_bad_override);
+  ASSERT(Isolate::Current()->ErrorOnBadOverrideEnabled());
   ASSERT((bound_error != NULL) && bound_error->IsNull());
   // Check that this function's signature type is a subtype of the other
   // function's signature type.
   if (!TypeTest(kIsSubtypeOf, Object::null_type_arguments(),
                 other, Object::null_type_arguments(), bound_error)) {
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
     *bound_error = LanguageError::NewFormatted(
         *bound_error,  // A bound error if non null.
         Script::Handle(other.script()),
@@ skipping 7668 matching lines @@
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.Length() >= cls.NumTypeArguments()));
   }
   Class& other_class = Class::Handle(isolate);
   TypeArguments& other_type_arguments = TypeArguments::Handle(isolate);
   // Note that we may encounter a bound error in checked mode.
   if (!other.IsInstantiated()) {
     const AbstractType& instantiated_other = AbstractType::Handle(
         isolate, other.InstantiateFrom(other_instantiator, bound_error));
     if ((bound_error != NULL) && !bound_error->IsNull()) {
-      ASSERT(FLAG_enable_type_checks);
+      ASSERT(Isolate::Current()->TypeChecksEnabled());
       return false;
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
   }
   return cls.IsSubtypeOf(type_arguments, other_class, other_type_arguments,
                          bound_error);
@@ skipping 648 matching lines @@
     // more specific than test.
     ASSERT(test_kind == kIsMoreSpecificThan);
     return false;
   }
   // In case the type checked in a type test is malbounded, the code generator
   // may compile a throw instead of a run time call performing the type check.
   // However, in checked mode, a function type may include malbounded result
   // type and/or malbounded parameter types, which will then be encountered here
   // at run time.
   if (IsMalbounded()) {
-    ASSERT(FLAG_enable_type_checks);
+    ASSERT(Isolate::Current()->TypeChecksEnabled());
     if ((bound_error != NULL) && bound_error->IsNull()) {
       *bound_error = error();
     }
     return false;
   }
   if (other.IsMalbounded()) {
-    ASSERT(FLAG_enable_type_checks);
+    ASSERT(Isolate::Current()->TypeChecksEnabled());
     if ((bound_error != NULL) && bound_error->IsNull()) {
       *bound_error = other.error();
     }
     return false;
   }
   if (IsBoundedType() || other.IsBoundedType()) {
     if (Equals(other)) {
       return true;
     }
     return false;  // TODO(regis): We should return "maybe after instantiation".
@@ skipping 186 matching lines @@
 bool Type::IsMalformed() const {
   if (raw_ptr()->error_ == LanguageError::null()) {
     return false;
   }
   const LanguageError& type_error = LanguageError::Handle(error());
   return type_error.kind() == Report::kMalformedType;
 }
 
 
 bool Type::IsMalbounded() const {
-  if (!FLAG_enable_type_checks) {
+  if (!Isolate::Current()->TypeChecksEnabled()) {
     return false;
   }
   if (raw_ptr()->error_ == LanguageError::null()) {
     return false;
   }
   const LanguageError& type_error = LanguageError::Handle(error());
   return type_error.kind() == Report::kMalboundedType;
 }
 
 
 bool Type::IsMalformedOrMalbounded() const {
   if (raw_ptr()->error_ == LanguageError::null()) {
     return false;
   }
   const LanguageError& type_error = LanguageError::Handle(error());
   if (type_error.kind() == Report::kMalformedType) {
     return true;
   }
   ASSERT(type_error.kind() == Report::kMalboundedType);
-  return FLAG_enable_type_checks;
+  return Isolate::Current()->TypeChecksEnabled();
 }
 
 
 void Type::set_error(const LanguageError& value) const {
   StorePointer(&raw_ptr()->error_, value.raw());
 }
 
 
 void Type::set_is_resolved() const {
   ASSERT(!IsResolved());
@@ skipping 956 matching lines @@
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     GrowableObjectArray* trail) const {
   ASSERT(IsFinalized());
   AbstractType& bounded_type = AbstractType::Handle(type());
   if (!bounded_type.IsInstantiated()) {
     bounded_type = bounded_type.InstantiateFrom(instantiator_type_arguments,
                                                 bound_error,
                                                 trail);
   }
-  if (FLAG_enable_type_checks &&
+  if ((Isolate::Current()->TypeChecksEnabled()) &&
       (bound_error != NULL) && bound_error->IsNull()) {
     AbstractType& upper_bound = AbstractType::Handle(bound());
     ASSERT(!upper_bound.IsObjectType() && !upper_bound.IsDynamicType());
     const TypeParameter& type_param = TypeParameter::Handle(type_parameter());
     if (!upper_bound.IsInstantiated()) {
       upper_bound = upper_bound.InstantiateFrom(instantiator_type_arguments,
                                                 bound_error,
                                                 trail);
     }
     if (bound_error->IsNull()) {
@@ skipping 5112 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart