clang-format runtime/vm

runtime/vm/object_store.h

 // 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.
 
 #ifndef RUNTIME_VM_OBJECT_STORE_H_
 #define RUNTIME_VM_OBJECT_STORE_H_
 
 #include "vm/object.h"
 
 namespace dart {
@@ skipping 29 matching lines @@
   RawClass* object_class() const {
     ASSERT(object_class_ != Object::null());
     return object_class_;
   }
   void set_object_class(const Class& value) { object_class_ = value.raw(); }
   static intptr_t object_class_offset() {
     return OFFSET_OF(ObjectStore, object_class_);
   }
 
   RawType* object_type() const { return object_type_; }
-  void set_object_type(const Type& value) {
-    object_type_ = value.raw();
-  }
+  void set_object_type(const Type& value) { object_type_ = value.raw(); }
 
   RawClass* null_class() const {
     ASSERT(null_class_ != Object::null());
     return null_class_;
   }
   void set_null_class(const Class& value) { null_class_ = value.raw(); }
 
   RawType* null_type() const { return null_type_; }
-  void set_null_type(const Type& value) {
-    null_type_ = value.raw();
-  }
+  void set_null_type(const Type& value) { null_type_ = value.raw(); }
 
   RawType* function_type() const { return function_type_; }
-  void set_function_type(const Type& value) {
-    function_type_ = value.raw();
-  }
+  void set_function_type(const Type& value) { function_type_ = value.raw(); }
 
   RawClass* closure_class() const { return closure_class_; }
-  void set_closure_class(const Class& value) {
-    closure_class_ = value.raw();
-  }
+  void set_closure_class(const Class& value) { closure_class_ = value.raw(); }
 
   RawType* number_type() const { return number_type_; }
-  void set_number_type(const Type& value) {
-    number_type_ = value.raw();
-  }
+  void set_number_type(const Type& value) { number_type_ = value.raw(); }
 
   RawType* int_type() const { return int_type_; }
-  void set_int_type(const Type& value) {
-    int_type_ = value.raw();
-  }
+  void set_int_type(const Type& value) { int_type_ = value.raw(); }
   static intptr_t int_type_offset() {
     return OFFSET_OF(ObjectStore, int_type_);
   }
 
   RawClass* integer_implementation_class() const {
     return integer_implementation_class_;
   }
   void set_integer_implementation_class(const Class& value) {
     integer_implementation_class_ = value.raw();
   }
@@ skipping 16 matching lines @@
   RawClass* mint_class() const { return mint_class_; }
   void set_mint_class(const Class& value) { mint_class_ = value.raw(); }
 
   RawType* mint_type() const { return mint_type_; }
   void set_mint_type(const Type& value) { mint_type_ = value.raw(); }
 
   RawClass* bigint_class() const { return bigint_class_; }
   void set_bigint_class(const Class& value) { bigint_class_ = value.raw(); }
 
   RawType* string_type() const { return string_type_; }
-  void set_string_type(const Type& value) {
-    string_type_ = value.raw();
-  }
+  void set_string_type(const Type& value) { string_type_ = value.raw(); }
   static intptr_t string_type_offset() {
     return OFFSET_OF(ObjectStore, string_type_);
   }
 
-  RawClass* compiletime_error_class() const {
-    return compiletime_error_class_;
-  }
+  RawClass* compiletime_error_class() const { return compiletime_error_class_; }
   void set_compiletime_error_class(const Class& value) {
     compiletime_error_class_ = value.raw();
   }
 
   RawClass* future_class() const { return future_class_; }
-  void set_future_class(const Class& value) {
-    future_class_ = value.raw();
-  }
+  void set_future_class(const Class& value) { future_class_ = value.raw(); }
 
   RawClass* completer_class() const { return completer_class_; }
   void set_completer_class(const Class& value) {
     completer_class_ = value.raw();
   }
 
   RawClass* stream_iterator_class() const { return stream_iterator_class_; }
   void set_stream_iterator_class(const Class& value) {
     stream_iterator_class_ = value.raw();
   }
 
   RawClass* symbol_class() { return symbol_class_; }
-  void set_symbol_class(const Class& value) {
-    symbol_class_ = value.raw();
-  }
+  void set_symbol_class(const Class& value) { symbol_class_ = value.raw(); }
 
   RawClass* one_byte_string_class() const { return one_byte_string_class_; }
   void set_one_byte_string_class(const Class& value) {
     one_byte_string_class_ = value.raw();
   }
 
   RawClass* two_byte_string_class() const { return two_byte_string_class_; }
   void set_two_byte_string_class(const Class& value) {
     two_byte_string_class_ = value.raw();
   }
@@ skipping 35 matching lines @@
   RawClass* growable_object_array_class() const {
     return growable_object_array_class_;
   }
   void set_growable_object_array_class(const Class& value) {
     growable_object_array_class_ = value.raw();
   }
   static intptr_t growable_object_array_class_offset() {
     return OFFSET_OF(ObjectStore, growable_object_array_class_);
   }
 
-  RawClass* linked_hash_map_class() const {
-    return linked_hash_map_class_;
-  }
+  RawClass* linked_hash_map_class() const { return linked_hash_map_class_; }
   void set_linked_hash_map_class(const Class& value) {
     linked_hash_map_class_ = value.raw();
   }
 
-  RawClass* float32x4_class() const {
-    return float32x4_class_;
-  }
+  RawClass* float32x4_class() const { return float32x4_class_; }
   void set_float32x4_class(const Class& value) {
     float32x4_class_ = value.raw();
   }
 
   RawType* float32x4_type() const { return float32x4_type_; }
   void set_float32x4_type(const Type& value) { float32x4_type_ = value.raw(); }
 
-  RawClass* int32x4_class() const {
-    return int32x4_class_;
-  }
-  void set_int32x4_class(const Class& value) {
-    int32x4_class_ = value.raw();
-  }
+  RawClass* int32x4_class() const { return int32x4_class_; }
+  void set_int32x4_class(const Class& value) { int32x4_class_ = value.raw(); }
 
   RawType* int32x4_type() const { return int32x4_type_; }
   void set_int32x4_type(const Type& value) { int32x4_type_ = value.raw(); }
 
-  RawClass* float64x2_class() const {
-    return float64x2_class_;
-  }
+  RawClass* float64x2_class() const { return float64x2_class_; }
   void set_float64x2_class(const Class& value) {
     float64x2_class_ = value.raw();
   }
 
   RawType* float64x2_type() const { return float64x2_type_; }
   void set_float64x2_type(const Type& value) { float64x2_type_ = value.raw(); }
 
-  RawClass* error_class() const {
-    return error_class_;
-  }
-  void set_error_class(const Class& value) {
-    error_class_ = value.raw();
-  }
+  RawClass* error_class() const { return error_class_; }
+  void set_error_class(const Class& value) { error_class_ = value.raw(); }
   static intptr_t error_class_offset() {
     return OFFSET_OF(ObjectStore, error_class_);
   }
 
-  RawClass* weak_property_class() const {
-    return weak_property_class_;
-  }
+  RawClass* weak_property_class() const { return weak_property_class_; }
   void set_weak_property_class(const Class& value) {
     weak_property_class_ = value.raw();
   }
 
   RawArray* symbol_table() const { return symbol_table_; }
   void set_symbol_table(const Array& value) { symbol_table_ = value.raw(); }
 
-  RawArray* canonical_types() const {
-    return canonical_types_;
-  }
+  RawArray* canonical_types() const { return canonical_types_; }
   void set_canonical_types(const Array& value) {
     canonical_types_ = value.raw();
   }
 
   RawArray* canonical_type_arguments() const {
     return canonical_type_arguments_;
   }
   void set_canonical_type_arguments(const Array& value) {
     canonical_type_arguments_ = value.raw();
   }
@@ skipping 60 matching lines @@
   }
 
   RawLibrary* native_wrappers_library() const {
     return native_wrappers_library_;
   }
   void set_native_wrappers_library(const Library& value) {
     native_wrappers_library_ = value.raw();
   }
 
   RawLibrary* root_library() const { return root_library_; }
-  void set_root_library(const Library& value) {
-    root_library_ = value.raw();
-  }
+  void set_root_library(const Library& value) { root_library_ = value.raw(); }
 
   RawGrowableObjectArray* libraries() const { return libraries_; }
   void set_libraries(const GrowableObjectArray& value) {
     libraries_ = value.raw();
   }
 
   RawArray* libraries_map() const { return libraries_map_; }
-  void set_libraries_map(const Array& value) {
-    libraries_map_ = value.raw();
-  }
+  void set_libraries_map(const Array& value) { libraries_map_ = value.raw(); }
 
   RawGrowableObjectArray* closure_functions() const {
     return closure_functions_;
   }
   void set_closure_functions(const GrowableObjectArray& value) {
     ASSERT(!value.IsNull());
     closure_functions_ = value.raw();
   }
 
   RawGrowableObjectArray* pending_classes() const { return pending_classes_; }
   void set_pending_classes(const GrowableObjectArray& value) {
     ASSERT(!value.IsNull());
     pending_classes_ = value.raw();
   }
 
   RawGrowableObjectArray* pending_deferred_loads() const {
     return pending_deferred_loads_;
   }
   void clear_pending_deferred_loads() {
     pending_deferred_loads_ = GrowableObjectArray::New();
   }
 
   RawGrowableObjectArray* resume_capabilities() const {
     return resume_capabilities_;
   }
 
-  RawGrowableObjectArray* exit_listeners() const {
-    return exit_listeners_;
-  }
+  RawGrowableObjectArray* exit_listeners() const { return exit_listeners_; }
 
-  RawGrowableObjectArray* error_listeners() const {
-    return error_listeners_;
-  }
+  RawGrowableObjectArray* error_listeners() const { return error_listeners_; }
 
   RawContext* empty_context() const { return empty_context_; }
-  void set_empty_context(const Context& value) {
-    empty_context_ = value.raw();
-  }
+  void set_empty_context(const Context& value) { empty_context_ = value.raw(); }
 
   RawInstance* stack_overflow() const { return stack_overflow_; }
   void set_stack_overflow(const Instance& value) {
     stack_overflow_ = value.raw();
   }
 
   RawInstance* out_of_memory() const { return out_of_memory_; }
   void set_out_of_memory(const Instance& value) {
     out_of_memory_ = value.raw();
   }
 
   RawUnhandledException* preallocated_unhandled_exception() const {
     return preallocated_unhandled_exception_;
   }
   void set_preallocated_unhandled_exception(const UnhandledException& value) {
     preallocated_unhandled_exception_ = value.raw();
   }
 
   RawStacktrace* preallocated_stack_trace() const {
     return preallocated_stack_trace_;
   }
   void set_preallocated_stack_trace(const Stacktrace& value) {
     preallocated_stack_trace_ = value.raw();
   }
 
-  RawFunction* lookup_port_handler() const {
-    return lookup_port_handler_;
-  }
+  RawFunction* lookup_port_handler() const { return lookup_port_handler_; }
   void set_lookup_port_handler(const Function& function) {
     lookup_port_handler_ = function.raw();
   }
 
-  RawTypedData* empty_uint32_array() const {
-    return empty_uint32_array_;
-  }
+  RawTypedData* empty_uint32_array() const { return empty_uint32_array_; }
   void set_empty_uint32_array(const TypedData& array) {
     // Only set once.
     ASSERT(empty_uint32_array_ == TypedData::null());
     ASSERT(!array.IsNull());
     empty_uint32_array_ = array.raw();
   }
 
   RawFunction* handle_message_function() const {
     return handle_message_function_;
   }
   void set_handle_message_function(const Function& function) {
     handle_message_function_ = function.raw();
   }
 
   RawArray* library_load_error_table() const {
     return library_load_error_table_;
   }
   void set_library_load_error_table(const Array& table) {
     library_load_error_table_ = table.raw();
   }
   static intptr_t library_load_error_table_offset() {
     return OFFSET_OF(ObjectStore, library_load_error_table_);
   }
 
-  RawArray* unique_dynamic_targets() const {
-    return unique_dynamic_targets_;
-  }
+  RawArray* unique_dynamic_targets() const { return unique_dynamic_targets_; }
   void set_unique_dynamic_targets(const Array& value) {
     unique_dynamic_targets_ = value.raw();
   }
 
-  RawGrowableObjectArray* token_objects() const {
-    return token_objects_;
-  }
+  RawGrowableObjectArray* token_objects() const { return token_objects_; }
   void set_token_objects(const GrowableObjectArray& value) {
     token_objects_ = value.raw();
   }
 
-  RawArray* token_objects_map() const {
-    return token_objects_map_;
-  }
+  RawArray* token_objects_map() const { return token_objects_map_; }
   void set_token_objects_map(const Array& value) {
     token_objects_map_ = value.raw();
   }
 
   RawGrowableObjectArray* megamorphic_cache_table() const {
     return megamorphic_cache_table_;
   }
   void set_megamorphic_cache_table(const GrowableObjectArray& value) {
     megamorphic_cache_table_ = value.raw();
   }
-  RawCode* megamorphic_miss_code() const {
-    return megamorphic_miss_code_;
-  }
+  RawCode* megamorphic_miss_code() const { return megamorphic_miss_code_; }
   RawFunction* megamorphic_miss_function() const {
     return megamorphic_miss_function_;
   }
   void SetMegamorphicMissHandler(const Code& code, const Function& func) {
     // Hold onto the code so it is traced and not detached from the function.
     megamorphic_miss_code_ = code.raw();
     megamorphic_miss_function_ = func.raw();
   }
 
   RawFunction* simple_instance_of_function() const {
@@ skipping 110 matching lines @@
   V(RawArray*, library_load_error_table_)                                      \
   V(RawArray*, unique_dynamic_targets_)                                        \
   V(RawGrowableObjectArray*, token_objects_)                                   \
   V(RawArray*, token_objects_map_)                                             \
   V(RawGrowableObjectArray*, megamorphic_cache_table_)                         \
   V(RawCode*, megamorphic_miss_code_)                                          \
   V(RawFunction*, megamorphic_miss_function_)                                  \
   // Please remember the last entry must be referred in the 'to' function below.
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&object_class_); }
-#define DECLARE_OBJECT_STORE_FIELD(type, name)                                 \
-  type name;
-OBJECT_STORE_FIELD_LIST(DECLARE_OBJECT_STORE_FIELD)
+#define DECLARE_OBJECT_STORE_FIELD(type, name) type name;
+  OBJECT_STORE_FIELD_LIST(DECLARE_OBJECT_STORE_FIELD)
 #undef DECLARE_OBJECT_STORE_FIELD
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&megamorphic_miss_function_);
   }
   RawObject** to_snapshot(Snapshot::Kind kind) {
     switch (kind) {
       case Snapshot::kCore:
         return reinterpret_cast<RawObject**>(&library_load_error_table_);
       case Snapshot::kAppWithJIT:
       case Snapshot::kAppNoJIT:
@@ skipping 10 matching lines @@
 
   friend class Serializer;
   friend class Deserializer;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectStore);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_STORE_H_