Fix http://dartbug.com/23578:

runtime/vm/isolate.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/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 36 matching lines @@
             "Pause isolates before starting.");
 DEFINE_FLAG(bool, pause_isolates_on_exit, false,
             "Pause isolates exiting.");
 DEFINE_FLAG(bool, break_at_isolate_spawn, false,
             "Insert a one-time breakpoint at the entrypoint for all spawned "
             "isolates");
 DEFINE_FLAG(charp, isolate_log_filter, NULL,
             "Log isolates whose name include the filter. "
             "Default: service isolate log messages are suppressed.");
 
+// TODO(iposva): Make these isolate specific flags inaccessible using the
+// regular FLAG_xyz pattern.
+// These flags are per-isolate and only influence the defaults.
+DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
+DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
+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.");
+
+static void CheckedModeHandler(bool value) {
+  FLAG_enable_asserts = value;
+  FLAG_enable_type_checks = value;
+}
+
+// --enable-checked-mode and --checked both enable checked mode which is
+// equivalent to setting --enable-asserts and --enable-type-checks.
+DEFINE_FLAG_HANDLER(CheckedModeHandler,
+                    enable_checked_mode,
+                    "Enable checked mode.");
+
+DEFINE_FLAG_HANDLER(CheckedModeHandler,
+                    checked,
+                    "Enable checked mode.");
+
+
 // Quick access to the locally defined isolate() method.
 #define I (isolate())
 
 #if defined(DEBUG)
 // Helper class to ensure that a live origin_id is never reused
 // and assigned to an isolate.
 class VerifyOriginId : public IsolateVisitor {
  public:
   explicit VerifyOriginId(Dart_Port id) : id_(id) {}
 
@@ skipping 462 matching lines @@
   I->NotifyErrorListeners(exc_str, stacktrace_str);
 
   if (I->ErrorsFatal()) {
     I->object_store()->set_sticky_error(result);
     return false;
   }
   return true;
 }
 
 
+Isolate::Flags::Flags()
+  : type_checks_(FLAG_enable_type_checks),
+    asserts_(FLAG_enable_asserts),
+    error_on_bad_type_(FLAG_error_on_bad_type),
+    error_on_bad_override_(FLAG_error_on_bad_override) {}
+
+
+void Isolate::Flags::CopyFrom(const Flags& orig) {
+  type_checks_ = orig.type_checks();
+  asserts_ = orig.asserts();
+  error_on_bad_type_ = orig.error_on_bad_type();
+  error_on_bad_override_ = orig.error_on_bad_override();
+}
+
+
+void Isolate::Flags::CopyFrom(const Dart_IsolateFlags& api_flags) {
+  type_checks_ = api_flags.enable_type_checks;
+  asserts_ = api_flags.enable_asserts;
+  // Leave others at defaults.
+}
+
+
+void Isolate::Flags::CopyTo(Dart_IsolateFlags* api_flags) const {
+  api_flags->version = DART_FLAGS_CURRENT_VERSION;
+  api_flags->enable_type_checks = type_checks();
+  api_flags->enable_asserts = asserts();
+}
+
+
 #if defined(DEBUG)
 // static
 void BaseIsolate::AssertCurrent(BaseIsolate* isolate) {
   ASSERT(isolate == Isolate::Current());
 }
 #endif  // defined(DEBUG)
 
 #if defined(DEBUG)
 #define REUSABLE_HANDLE_SCOPE_INIT(object)                                     \
   reusable_##object##_handle_scope_active_(false),
 #else
 #define REUSABLE_HANDLE_SCOPE_INIT(object)
 #endif  // defined(DEBUG)
 
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
-Isolate::Isolate()
+Isolate::Isolate(const Dart_IsolateFlags& api_flags)
   :   mutator_thread_(NULL),
       vm_tag_(0),
       store_buffer_(),
       message_notify_callback_(NULL),
       name_(NULL),
       debugger_name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
       origin_id_(0),
       pause_capability_(0),
       terminate_capability_(0),
       errors_fatal_(true),
       heap_(NULL),
       object_store_(NULL),
       top_exit_frame_info_(0),
       init_callback_data_(NULL),
       environment_callback_(NULL),
       library_tag_handler_(NULL),
       api_state_(NULL),
       stub_code_(NULL),
       debugger_(NULL),
       single_step_(false),
       resume_request_(false),
       has_compiled_(false),
-      strict_compilation_(false),
+      flags_(),

[Florian Schneider, 2015/06/08 11:25:49]

flags_(api_flags) and remove .CopyFrom below

       random_(),
       simulator_(NULL),
       long_jump_base_(NULL),
       timer_list_(),
       deopt_id_(0),
       mutex_(new Mutex()),
       stack_limit_(0),
       saved_stack_limit_(0),
       stack_base_(0),
       stack_overflow_flags_(0),
@@ skipping 21 matching lines @@
       current_tag_(UserTag::null()),
       default_tag_(UserTag::null()),
       deoptimized_code_array_(GrowableObjectArray::null()),
       metrics_list_head_(NULL),
       cha_(NULL),
       next_(NULL),
       pause_loop_monitor_(NULL),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_INIT)
       reusable_handles_() {
+  flags_.CopyFrom(api_flags);
   set_vm_tag(VMTag::kEmbedderTagId);
   set_user_tag(UserTags::kDefaultUserTag);
 }
 
 #undef REUSABLE_HANDLE_SCOPE_INIT
 #undef REUSABLE_HANDLE_INITIALIZERS
 
 Isolate::~Isolate() {
   free(name_);
   free(debugger_name_);
@@ skipping 31 matching lines @@
 #endif  // DEBUG
 
 
 void Isolate::InitOnce() {
   create_callback_ = NULL;
   isolates_list_monitor_ = new Monitor();
   ASSERT(isolates_list_monitor_ != NULL);
 }
 
 
-Isolate* Isolate::Init(const char* name_prefix, bool is_vm_isolate) {
-  Isolate* result = new Isolate();
+Isolate* Isolate::Init(const char* name_prefix,
+                       const Dart_IsolateFlags& api_flags,
+                       bool is_vm_isolate) {
+  Isolate* result = new Isolate(api_flags);
   ASSERT(result != NULL);
 
   // Initialize metrics.
 #define ISOLATE_METRIC_INIT(type, variable, name, unit)                        \
   result->metric_##variable##_.Init(result, name, NULL, Metric::unit);
   ISOLATE_METRIC_LIST(ISOLATE_METRIC_INIT);
 #undef ISOLATE_METRIC_INIT
 
   // TODO(5411455): For now just set the recently created isolate as
   // the current isolate.
@@ skipping 1110 matching lines @@
   ASSERT(!obj.IsError());
   Instance& instance = Instance::Handle(isolate);
   instance ^= obj.raw();  // Can't use Instance::Cast because may be null.
   return instance.raw();
 }
 
 
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      const Function& func,
                                      const Instance& message,
-                                     bool paused,
-                                     bool checkedFlag)
+                                     bool paused)
     : isolate_(NULL),
       parent_port_(parent_port),
       script_url_(NULL),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
-      paused_(paused),
-      checked_(checkedFlag) {
+      isolate_flags_(),

[Florian Schneider, 2015/06/08 11:25:49]

isolate(Isolate::Current()->flags()) and remove ->CopyFrom below.

+      paused_(paused) {
   script_url_ = NULL;
   const Class& cls = Class::Handle(func.Owner());
   const Library& lib = Library::Handle(cls.library());
   const String& lib_url = String::Handle(lib.url());
   library_url_ = strdup(lib_url.ToCString());
 
   const String& func_name = String::Handle(func.name());
   function_name_ = strdup(func_name.ToCString());
   if (!cls.IsTopLevel()) {
     const String& class_name = String::Handle(cls.Name());
     class_name_ = strdup(class_name.ToCString());
   }
   bool can_send_any_object = true;
   SerializeObject(message,
                   &serialized_message_,
                   &serialized_message_len_,
                   can_send_any_object);
+  // Inherit flags from spawning isolate.
+  isolate_flags()->CopyFrom(Isolate::Current()->flags());
 }
 
 
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      const char* script_url,
                                      const char* package_root,
                                      const Instance& args,
                                      const Instance& message,
-                                     bool paused,
-                                     bool checkedFlag)
+                                     bool paused)
     : isolate_(NULL),
       parent_port_(parent_port),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
-      paused_(paused),
-      checked_(checkedFlag) {
+      isolate_flags_(),

[Florian Schneider, 2015/06/08 11:25:49]

isolate_flags_(Isolate::Current()->flags())  and remove ->CopyFrom below.

+      paused_(paused) {
   script_url_ = strdup(script_url);
   if (package_root != NULL) {
     package_root_ = strdup(package_root);
   }
   library_url_ = NULL;
   function_name_ = strdup("main");
   bool can_send_any_object = false;
   SerializeObject(args,
                   &serialized_args_,
                   &serialized_args_len_,
                   can_send_any_object);
   SerializeObject(message,
                   &serialized_message_,
                   &serialized_message_len_,
                   can_send_any_object);
+  // By default inherit flags from spawning isolate. These can be overridden
+  // from the calling code.
+  isolate_flags()->CopyFrom(Isolate::Current()->flags());
 }
 
 
 IsolateSpawnState::~IsolateSpawnState() {
   free(script_url_);
   free(package_root_);
   free(library_url_);
   free(function_name_);
   free(class_name_);
   free(serialized_args_);
@@ skipping 80 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart