VM: Re-format to use at most one newline between functions

runtime/lib/object.cc

 // Copyright (c) 2011, 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/bootstrap_natives.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/code_patcher.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_type_checks);
 
 DEFINE_NATIVE_ENTRY(DartAsync_fatal, 1) {
   // The dart:async library code entered an unrecoverable state.
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   const char* msg = instance.ToCString();
   OS::PrintErr("Fatal error in dart:async: %s\n", msg);
   FATAL(msg);
   return Object::null();
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_equals, 1) {
   // Implemented in the flow graph builder.
   UNREACHABLE();
   return Object::null();
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_getHash, 1) {
-  // Please note that no handle is created for the argument.
-  // This is safe since the argument is only used in a tail call.
-  // The performance benefit is more than 5% when using hashCode.
+// Please note that no handle is created for the argument.
+// This is safe since the argument is only used in a tail call.
+// The performance benefit is more than 5% when using hashCode.
 #if defined(HASH_IN_OBJECT_HEADER)
   return Smi::New(Object::GetCachedHash(arguments->NativeArgAt(0)));
 #else
   Heap* heap = isolate->heap();
   ASSERT(arguments->NativeArgAt(0)->IsDartInstance());
   return Smi::New(heap->GetHash(arguments->NativeArgAt(0)));
 #endif
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_setHash, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, hash, arguments->NativeArgAt(1));
 #if defined(HASH_IN_OBJECT_HEADER)
   Object::SetCachedHash(arguments->NativeArgAt(0), hash.Value());
 #else
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   Heap* heap = isolate->heap();
   heap->SetHash(instance.raw(), hash.Value());
 #endif
   return Object::null();
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_toString, 1) {
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   if (instance.IsString()) {
     return instance.raw();
   }
   const char* c_str = instance.ToCString();
   return String::New(c_str);
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_noSuchMethod, 6) {
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Bool, is_method, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(String, member_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, invocation_type, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, func_args, arguments->NativeArgAt(4));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, func_named_args,
                                arguments->NativeArgAt(5));
   const Array& dart_arguments = Array::Handle(Array::New(6));
   dart_arguments.SetAt(0, instance);
@@ skipping 29 matching lines @@
       for (int i = 1; i < total_num_parameters; i++) {
         array.SetAt(i - 1, String::Handle(function.ParameterNameAt(i)));
       }
       dart_arguments.SetAt(5, array);
     }
   }
   Exceptions::ThrowByType(Exceptions::kNoSuchMethod, dart_arguments);
   return Object::null();
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_runtimeType, 1) {
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   if (instance.IsString()) {
     return Type::StringType();
   } else if (instance.IsInteger()) {
     return Type::IntType();
   } else if (instance.IsDouble()) {
     return Type::Double();
   }
   return instance.GetType(Heap::kNew);
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_haveSameRuntimeType, 2) {
   const Instance& left = Instance::CheckedHandle(arguments->NativeArgAt(0));
   const Instance& right = Instance::CheckedHandle(arguments->NativeArgAt(1));
 
   const intptr_t left_cid = left.GetClassId();
   const intptr_t right_cid = right.GetClassId();
 
   if (left_cid != right_cid) {
     if (RawObject::IsIntegerClassId(left_cid)) {
       return Bool::Get(RawObject::IsIntegerClassId(right_cid)).raw();
@@ skipping 18 matching lines @@
     return Bool::True().raw();
   }
 
   const TypeArguments& left_type_arguments =
       TypeArguments::Handle(left.GetTypeArguments());
   const TypeArguments& right_type_arguments =
       TypeArguments::Handle(right.GetTypeArguments());
   return Bool::Get(left_type_arguments.Equals(right_type_arguments)).raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_instanceOf, 4) {
   const Instance& instance =
       Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
   const TypeArguments& function_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(2));
   const AbstractType& type =
       AbstractType::CheckedHandle(zone, arguments->NativeArgAt(3));
   ASSERT(type.IsFinalized());
@@ skipping 57 matching lines @@
     String& bound_error_message =
         String::Handle(zone, String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(location, AbstractType::Handle(zone),
                                         AbstractType::Handle(zone),
                                         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   return Bool::Get(is_instance_of).raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(Object_as, 4) {
   const Instance& instance =
       Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
   const TypeArguments& function_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(2));
   AbstractType& type =
       AbstractType::CheckedHandle(zone, arguments->NativeArgAt(3));
   ASSERT(type.IsFinalized());
@@ skipping 42 matching lines @@
           String::Handle(zone, String::New(bound_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
           location, instance_type, AbstractType::Handle(zone), Symbols::Empty(),
           bound_error_message);
     }
     UNREACHABLE();
   }
   return instance.raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(AbstractType_toString, 1) {
   const AbstractType& type =
       AbstractType::CheckedHandle(zone, arguments->NativeArgAt(0));
   return type.UserVisibleName();
 }
 
-
 DEFINE_NATIVE_ENTRY(LibraryPrefix_invalidateDependentCode, 1) {
   const LibraryPrefix& prefix =
       LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
   prefix.InvalidateDependentCode();
   return Bool::Get(true).raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(LibraryPrefix_load, 1) {
   const LibraryPrefix& prefix =
       LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
   bool hasCompleted = prefix.LoadLibrary();
   return Bool::Get(hasCompleted).raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(LibraryPrefix_loadError, 1) {
   const LibraryPrefix& prefix =
       LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
   // Currently all errors are Dart instances, e.g. I/O errors
   // created by deferred loading code. LanguageErrors from
   // failed loading or finalization attempts are propagated and result
   // in the isolate's death.
   const Instance& error = Instance::Handle(zone, prefix.LoadError());
   return error.raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(LibraryPrefix_isLoaded, 1) {
   const LibraryPrefix& prefix =
       LibraryPrefix::CheckedHandle(zone, arguments->NativeArgAt(0));
   return Bool::Get(prefix.is_loaded()).raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(Internal_inquireIs64Bit, 0) {
 #if defined(ARCH_IS_64_BIT)
   return Bool::True().raw();
 #else
   return Bool::False().raw();
 #endif  // defined(ARCH_IS_64_BIT)
 }
 
-
 DEFINE_NATIVE_ENTRY(Internal_prependTypeArguments, 3) {
   const TypeArguments& function_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0));
   const TypeArguments& parent_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
   if (function_type_arguments.IsNull() && parent_type_arguments.IsNull()) {
     return TypeArguments::null();
   }
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, smi_len, arguments->NativeArgAt(2));
   const intptr_t len = smi_len.Value();
@@ skipping 11 matching lines @@
   for (intptr_t i = split; i < len; i++) {
     type = function_type_arguments.IsNull()
                ? Type::DynamicType()
                : function_type_arguments.TypeAt(i - split);
     result.SetTypeAt(i, type);
   }
   return result.Canonicalize();
 }
 
 }  // namespace dart