- Remove Isolate::Flags structure and store flags directly in isolate.

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 5924 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(Isolate::Current()->flags().error_on_bad_override());
+  ASSERT(Isolate::Current()->error_on_bad_override());
   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,
                 Heap::kOld)) {
     // 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.
@@ skipping 8273 matching lines @@
       return true;
     }
     Function& other_signature = Function::Handle(zone);
     TypeArguments& other_type_arguments = TypeArguments::Handle(zone);
     // Note that we may encounter a bound error in checked mode.
     if (!other.IsInstantiated()) {
       AbstractType& instantiated_other = AbstractType::Handle(
           zone, other.InstantiateFrom(other_instantiator, bound_error,
                                       NULL, NULL, Heap::kOld));
       if ((bound_error != NULL) && !bound_error->IsNull()) {
-        ASSERT(Isolate::Current()->flags().type_checks());
+        ASSERT(Isolate::Current()->type_checks());
         return false;
       }
       if (instantiated_other.IsTypeRef()) {
         instantiated_other = TypeRef::Cast(instantiated_other).type();
       }
       if (instantiated_other.IsDynamicType() ||
           instantiated_other.IsObjectType() ||
           instantiated_other.IsDartFunctionType()) {
         return true;
       }
@@ skipping 35 matching lines @@
            (type_arguments.Length() >= cls.NumTypeArguments()));
   }
   Class& other_class = Class::Handle(zone);
   TypeArguments& other_type_arguments = TypeArguments::Handle(zone);
   AbstractType& instantiated_other = AbstractType::Handle(zone, other.raw());
   // Note that we may encounter a bound error in checked mode.
   if (!other.IsInstantiated()) {
     instantiated_other = other.InstantiateFrom(other_instantiator, bound_error,
                                                NULL, NULL, Heap::kOld);
     if ((bound_error != NULL) && !bound_error->IsNull()) {
-      ASSERT(Isolate::Current()->flags().type_checks());
+      ASSERT(Isolate::Current()->type_checks());
       return false;
     }
     if (instantiated_other.IsTypeRef()) {
       instantiated_other = TypeRef::Cast(instantiated_other).type();
     }
     if (instantiated_other.IsDynamicType()) {
       return true;
     }
   }
   other_type_arguments = instantiated_other.arguments();
@@ skipping 672 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(Isolate::Current()->flags().type_checks());
+    ASSERT(Isolate::Current()->type_checks());
     if ((bound_error != NULL) && bound_error->IsNull()) {
       *bound_error = error();
     }
     return false;
   }
   if (other.IsMalbounded()) {
-    ASSERT(Isolate::Current()->flags().type_checks());
+    ASSERT(Isolate::Current()->type_checks());
     if ((bound_error != NULL) && bound_error->IsNull()) {
       *bound_error = other.error();
     }
     return false;
   }
   if (other.IsObjectType() || other.IsDynamicType()) {
     return true;
   }
   if (IsBoundedType() || other.IsBoundedType()) {
     if (Equals(other)) {
@@ skipping 230 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 (!Isolate::Current()->flags().type_checks()) {
+  if (!Isolate::Current()->type_checks()) {
     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 Isolate::Current()->flags().type_checks();
+  return Isolate::Current()->type_checks();
 }
 
 
 void Type::set_error(const LanguageError& value) const {
   StorePointer(&raw_ptr()->error_, value.raw());
 }
 
 
 void Type::SetIsResolved() const {
   ASSERT(!IsResolved());
@@ skipping 466 matching lines @@
 bool FunctionType::IsMalformed() const {
   if (raw_ptr()->error_ == LanguageError::null()) {
     return false;
   }
   const LanguageError& type_error = LanguageError::Handle(error());
   return type_error.kind() == Report::kMalformedType;
 }
 
 
 bool FunctionType::IsMalbounded() const {
-  if (!Isolate::Current()->flags().type_checks()) {
+  if (!Isolate::Current()->type_checks()) {
     return false;
   }
   if (raw_ptr()->error_ == LanguageError::null()) {
     return false;
   }
   const LanguageError& type_error = LanguageError::Handle(error());
   return type_error.kind() == Report::kMalboundedType;
 }
 
 
 bool FunctionType::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 Isolate::Current()->flags().type_checks();
+  return Isolate::Current()->type_checks();
 }
 
 
 void FunctionType::set_error(const LanguageError& value) const {
   StorePointer(&raw_ptr()->error_, value.raw());
 }
 
 
 void FunctionType::SetIsResolved() const {
   ASSERT(!IsResolved());
@@ skipping 922 matching lines @@
         bounded_type.InstantiateFrom(instantiator_type_arguments,
                                      bound_error,
                                      instantiation_trail,
                                      bound_trail,
                                      space);
     // In case types of instantiator_type_arguments are not finalized
     // (or instantiated), then the instantiated_bounded_type is not finalized
     // (or instantiated) either.
     // Note that instantiator_type_arguments must have the final length, though.
   }
-  if ((Isolate::Current()->flags().type_checks()) &&
+  if ((Isolate::Current()->type_checks()) &&
       (bound_error != NULL) && bound_error->IsNull()) {
     AbstractType& upper_bound = AbstractType::Handle(bound());
     ASSERT(upper_bound.IsFinalized());
     ASSERT(!upper_bound.IsObjectType() && !upper_bound.IsDynamicType());
     AbstractType& instantiated_upper_bound =
         AbstractType::Handle(upper_bound.raw());
     if (!upper_bound.IsInstantiated()) {
       instantiated_upper_bound =
           upper_bound.InstantiateFrom(instantiator_type_arguments,
                                       bound_error,
@@ skipping 4725 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart