Allows turning on checked mode on a per-isolate basis

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/report.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, error_on_bad_override, false,
             "Report error for bad overrides.");
 DEFINE_FLAG(bool, error_on_bad_type, false,
             "Report error for malformed types.");
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, use_cha);
 
+
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
 
 // Removes optimized code once we load more classes, since --use_cha based
 // optimizations may have become invalid.
@@ skipping 328 matching lines @@
         Script::Handle(target_class.script()),
         factory.token_pos(),
         "class '%s' has no constructor or factory named '%s'",
         target_class_name.ToCString(),
         user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
-  if (FLAG_error_on_bad_override) {
+  if (Isolate::Current()->ErrorOnBadOverrideEnabled()) {
     // Verify that the target is compatible with the redirecting factory.
     Error& error = Error::Handle();
     if (!target.HasCompatibleParametersWith(factory, &error)) {
       const Script& script = Script::Handle(target_class.script());
       type = NewFinalizedMalformedType(
           error, script, target.token_pos(),
           "constructor '%s' has incompatible parameters with "
           "redirecting factory '%s'",
           String::Handle(target.name()).ToCString(),
           String::Handle(factory.name()).ToCString());
@@ skipping 589 matching lines @@
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, type parameter bounds are checked below, even for a raw type.
   TypeArguments& arguments =
       TypeArguments::Handle(isolate, parameterized_type.arguments());
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // Wrong number of type arguments. The type is mapped to the raw type.
-    if (FLAG_error_on_bad_type) {
+    if (Isolate::Current()->ErrorOnBadTypeEnabled()) {
       const String& type_class_name =
           String::Handle(isolate, type_class.Name());
       ReportError(cls, parameterized_type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     // Make the type raw and continue without reporting any error.
     // A static warning should have been reported.
     arguments = TypeArguments::null();
     parameterized_type.set_arguments(arguments);
@@ skipping 350 matching lines @@
         error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(I, field.value());
       if (!error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      Object::null_type_arguments(),
                                      &error))) {
-        if (FLAG_error_on_bad_type) {
+        if (Isolate::Current()->ErrorOnBadTypeEnabled()) {
           const AbstractType& const_value_type = AbstractType::Handle(
               I, const_value.GetType());
           const String& const_value_type_name = String::Handle(
               I, const_value_type.UserVisibleName());
           const String& type_name = String::Handle(I, type.UserVisibleName());
           ReportErrors(error, cls, field.token_pos(),
                        "error initializing static %s field '%s': "
                        "type '%s' is not a subtype of type '%s'",
                        field.is_const() ? "const" : "final",
                        name.ToCString(),
@@ skipping 42 matching lines @@
   // interfaces.
   array = cls.functions();
   Function& function = Function::Handle(I);
   Function& overridden_function = Function::Handle(I);
   const intptr_t num_functions = array.Length();
   Error& error = Error::Handle(I);
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     ResolveAndFinalizeSignature(cls, function);
     name = function.name();
-    if (FLAG_error_on_bad_override &&  // Report signature conflicts only.
+    // Report signature conflicts only.
+    if (Isolate::Current()->ErrorOnBadOverrideEnabled() &&
         !function.is_static() && !function.IsConstructor()) {
       // A constructor cannot override anything.
       for (intptr_t i = 0; i < interfaces.Length(); i++) {
         super_class ^= interfaces.At(i);
         // Finalize superclass since overrides check relies on all members
         // of the superclass to be finalized.
         FinalizeClass(super_class);
         overridden_function = super_class.LookupDynamicFunction(name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function,
@@ skipping 1127 matching lines @@
   if (num_type_arguments > 0) {
     if (num_type_arguments == num_type_parameters) {
       for (intptr_t i = 0; i < num_type_arguments; i++) {
         arg = type_args.TypeAt(i);
         arg = arg.CloneUnfinalized();
         ASSERT(!arg.IsBeingFinalized());
         collected_args.Add(arg);
       }
       return;
     }
-    if (FLAG_error_on_bad_type) {
+    if (Isolate::Current()->ErrorOnBadTypeEnabled()) {
       const String& type_class_name = String::Handle(type_class.Name());
       ReportError(cls, type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     // Discard provided type arguments and treat type as raw.
   }
   // Fill arguments with type dynamic.
   for (intptr_t i = 0; i < num_type_parameters; i++) {
     arg = Type::DynamicType();
@@ skipping 402 matching lines @@
 void ClassFinalizer::MarkTypeMalformed(const Error& prev_error,
                                        const Script& script,
                                        const Type& type,
                                        const char* format,
                                        va_list args) {
   LanguageError& error = LanguageError::Handle(
       LanguageError::NewFormattedV(
           prev_error, script, type.token_pos(),
           Report::kMalformedType, Heap::kOld,
           format, args));
-  if (FLAG_error_on_bad_type) {
+  if (Isolate::Current()->ErrorOnBadTypeEnabled()) {
     ReportError(error);
   }
   type.set_error(error);
   // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(Object::null_type_arguments());
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malformed types, since they may not be resolved.
@@ skipping 41 matching lines @@
                                             const Type& type,
                                             const char* format, ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle(
       LanguageError::NewFormattedV(
           prev_error, script, type.token_pos(),
           Report::kMalboundedType, Heap::kOld,
           format, args));
   va_end(args);
-  if (FLAG_error_on_bad_type) {
+  if (Isolate::Current()->ErrorOnBadTypeEnabled()) {
     ReportError(error);
   }
   type.set_error(error);
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malbounded types.
   }
 }
 
 
@@ skipping 94 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart