Fix http://dartbug.com/23578:

runtime/vm/isolate.h

 // 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.
 
 #ifndef VM_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/base_isolate.h"
 #include "vm/class_table.h"
 #include "vm/counters.h"
 #include "vm/handles.h"
 #include "vm/megamorphic_cache_table.h"
 #include "vm/metrics.h"
 #include "vm/random.h"
 #include "vm/store_buffer.h"
 #include "vm/tags.h"
 #include "vm/thread.h"
 #include "vm/os_thread.h"
 #include "vm/trace_buffer.h"
 #include "vm/timer.h"
 
 namespace dart {
 
-DECLARE_FLAG(bool, enable_type_checks);
-DECLARE_FLAG(bool, enable_asserts);
-DECLARE_FLAG(bool, error_on_bad_type);
-DECLARE_FLAG(bool, error_on_bad_override);
-
 // Forward declarations.
 class AbstractType;
 class ApiState;
 class Array;
 class Capability;
 class CHA;
 class Class;
 class Code;
 class CodeIndexTable;
 class CompilerStats;
@@ skipping 78 matching lines @@
 class Isolate : public BaseIsolate {
  public:
   ~Isolate();
 
   static inline Isolate* Current() {
     Thread* thread = Thread::Current();
     return thread == NULL ? NULL : thread->isolate();
   }
 
   static void InitOnce();
-  static Isolate* Init(const char* name_prefix, bool is_vm_isolate = false);
+  static Isolate* Init(const char* name_prefix,
+                       const Dart_IsolateFlags& api_flags,
+                       bool is_vm_isolate = false);
   void Shutdown();
 
   // Register a newly introduced class.
   void RegisterClass(const Class& cls);
   void RegisterClassAt(intptr_t index, const Class& cls);
   void ValidateClassTable();
 
   // Visit all object pointers.
   void VisitObjectPointers(ObjectPointerVisitor* visitor,
                            bool visit_prologue_weak_persistent_handles,
@@ skipping 236 matching lines @@
 
   void set_single_step(bool value) { single_step_ = value; }
   bool single_step() const { return single_step_; }
   static intptr_t single_step_offset() {
     return OFFSET_OF(Isolate, single_step_);
   }
 
   void set_has_compiled(bool value) { has_compiled_ = value; }
   bool has_compiled() const { return has_compiled_; }
 
-  void set_strict_compilation(bool value) { strict_compilation_ = value; }
-  bool strict_compilation() const { return strict_compilation_; }
-  bool TypeChecksEnabled() {
-    return FLAG_enable_type_checks || strict_compilation_;
-  }
-  bool AssertsEnabled() {
-    return FLAG_enable_asserts || strict_compilation_;
-  }
-  bool ErrorOnBadTypeEnabled() {
-    return FLAG_error_on_bad_type || strict_compilation_;
-  }
-  bool ErrorOnBadOverrideEnabled() {
-    return FLAG_error_on_bad_override || strict_compilation_;
+  // TODO(iposva): Evaluate whether two different isolate flag structures are
+  // needed. Currently it serves as a separation between publicly visible flags
+  // and VM internal flags.
+  class Flags : public ValueObject {
+   public:
+    // Construct default flags as specified by the options.
+    Flags();
+
+    bool type_checks() const { return type_checks_; }
+    bool asserts() const { return asserts_; }
+    bool error_on_bad_type() const { return error_on_bad_type_; }
+    bool error_on_bad_override() const { return error_on_bad_override_; }
+
+    void set_checked(bool val) {
+      type_checks_ = val;
+      asserts_ = val;
+    }
+
+    void CopyFrom(const Flags& orig);

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

Are these used outside constructors? Otherwise, just create

explicit Flags(const Flags& orig)

explicit Flags(const Dart_IsolateFlags& api_flags)

and use those instead, possibly make CopyFrom private - no need to expose
explicit a public CopyFrom method.

+    void CopyFrom(const Dart_IsolateFlags& api_flags);
+    void CopyTo(Dart_IsolateFlags* api_flags) const;
+
+   private:
+    bool type_checks_;
+    bool asserts_;
+    bool error_on_bad_type_;
+    bool error_on_bad_override_;
+
+    friend class Isolate;
+
+    DISALLOW_ALLOCATION();
+    DISALLOW_COPY_AND_ASSIGN(Flags);
+  };
+
+  const Flags& flags() const { return flags_; }
+
+  // Set the checks in the compiler to the highest level. Statically and when
+  // executing generated code. Needs to be called before any code has been
+  // compiled.
+  void set_strict_compilation() {
+    ASSERT(!has_compiled());
+    flags_.type_checks_ = true;
+    flags_.asserts_ = true;
+    flags_.error_on_bad_type_ = true;
+    flags_.error_on_bad_override_ = true;
   }
 
   // Requests that the debugger resume execution.
   void Resume() {
     resume_request_ = true;
   }
 
   // Returns whether the vm service has requested that the debugger
   // resume execution.
   bool GetAndClearResumeRequest() {
@@ skipping 261 matching lines @@
 #undef REUSABLE_HANDLE
 
   static void VisitIsolates(IsolateVisitor* visitor);
 
   Counters* counters() { return &counters_; }
 
   // Handle service messages until we are told to resume execution.
   void PauseEventHandler();
 
  private:
-  Isolate();
+  explicit Isolate(const Dart_IsolateFlags& api_flags);
 
   void BuildName(const char* name_prefix);
   void PrintInvokedFunctions();
 
   void ProfileIdle();
 
   void set_user_tag(uword tag) {
     user_tag_ = tag;
   }
 
@@ skipping 22 matching lines @@
   uword top_exit_frame_info_;
   void* init_callback_data_;
   Dart_EnvironmentCallback environment_callback_;
   Dart_LibraryTagHandler library_tag_handler_;
   ApiState* api_state_;
   StubCode* stub_code_;
   Debugger* debugger_;
   bool single_step_;
   bool resume_request_;
   bool has_compiled_;
-  bool strict_compilation_;
+  Flags flags_;
   Random random_;
   Simulator* simulator_;
   LongJumpScope* long_jump_base_;
   TimerList timer_list_;
   intptr_t deopt_id_;
   Mutex* mutex_;  // protects stack_limit_ and saved_stack_limit_.
   uword stack_limit_;
   uword saved_stack_limit_;
   uword stack_base_;
   uword stack_overflow_flags_;
@@ skipping 185 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SwitchIsolateScope);
 };
 
 
 class IsolateSpawnState {
  public:
   IsolateSpawnState(Dart_Port parent_port,
                     const Function& func,
                     const Instance& message,
-                    bool paused,
-                    bool checked);
+                    bool paused);
   IsolateSpawnState(Dart_Port parent_port,
                     const char* script_url,
                     const char* package_root,
                     const Instance& args,
                     const Instance& message,
-                    bool paused,
-                    bool checked);
+                    bool paused);
   ~IsolateSpawnState();
 
   Isolate* isolate() const { return isolate_; }
   void set_isolate(Isolate* value) { isolate_ = value; }
 
   Dart_Port parent_port() const { return parent_port_; }
   char* script_url() const { return script_url_; }
   char* package_root() const { return package_root_; }
   char* library_url() const { return library_url_; }
   char* class_name() const { return class_name_; }
   char* function_name() const { return function_name_; }
   bool is_spawn_uri() const { return library_url_ == NULL; }
   bool paused() const { return paused_; }
-  bool checked_mode() const { return checked_; }
+  Isolate::Flags* isolate_flags() { return &isolate_flags_; }
 
   RawObject* ResolveFunction();
   RawInstance* BuildArgs(Zone* zone);
   RawInstance* BuildMessage(Zone* zone);
   void Cleanup();
 
  private:
   Isolate* isolate_;
   Dart_Port parent_port_;
   char* script_url_;
   char* package_root_;
   char* library_url_;
   char* class_name_;
   char* function_name_;
   uint8_t* serialized_args_;
   intptr_t serialized_args_len_;
   uint8_t* serialized_message_;
   intptr_t serialized_message_len_;
+  Isolate::Flags isolate_flags_;
   bool paused_;
-  bool checked_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_