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

runtime/vm/resolver.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/resolver.h"
 
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 12 matching lines @@
 // arguments. The dynamic resolver actually checks that a valid number of named
 // arguments is passed in.
 RawFunction* Resolver::ResolveDynamic(const Instance& receiver,
                                       const String& function_name,
                                       const ArgumentsDescriptor& args_desc) {
   // Figure out type of receiver first.
   const Class& cls = Class::Handle(receiver.clazz());
   return ResolveDynamicForReceiverClass(cls, function_name, args_desc);
 }
 
-
 RawFunction* Resolver::ResolveDynamicForReceiverClass(
     const Class& receiver_class,
     const String& function_name,
     const ArgumentsDescriptor& args_desc,
     bool allow_add) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
   Function& function = Function::Handle(
       zone,
@@ skipping 10 matching lines @@
         function.AreValidArguments(args_desc, &error_message);
       }
       THR_Print("ResolveDynamic error '%s': %s.\n", function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
-
 RawFunction* Resolver::ResolveDynamicAnyArgs(Zone* zone,
                                              const Class& receiver_class,
                                              const String& function_name,
                                              bool allow_add) {
   Class& cls = Class::Handle(zone, receiver_class.raw());
   if (FLAG_trace_resolving) {
     THR_Print("ResolveDynamic '%s' for class %s\n", function_name.ToCString(),
               String::Handle(zone, cls.Name()).ToCString());
   }
 
@@ skipping 60 matching lines @@
           function ^= function.CreateMethodExtractor(function_name);
           return function.raw();
         }
       }
     }
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
-
 RawFunction* Resolver::ResolveStatic(const Library& library,
                                      const String& class_name,
                                      const String& function_name,
                                      intptr_t type_args_len,
                                      intptr_t num_arguments,
                                      const Array& argument_names) {
   ASSERT(!library.IsNull());
   Function& function = Function::Handle();
   if (class_name.IsNull() || (class_name.Length() == 0)) {
     // Check if we are referring to a top level function.
@@ skipping 28 matching lines @@
                                argument_names);
     }
     if (FLAG_trace_resolving && function.IsNull()) {
       THR_Print("ResolveStatic error: function '%s.%s' not found.\n",
                 class_name.ToCString(), function_name.ToCString());
     }
   }
   return function.raw();
 }
 
-
 RawFunction* Resolver::ResolveStatic(const Class& cls,
                                      const String& function_name,
                                      intptr_t type_args_len,
                                      intptr_t num_arguments,
                                      const Array& argument_names) {
   ASSERT(!cls.IsNull());
   if (FLAG_trace_resolving) {
     THR_Print("ResolveStatic '%s'\n", function_name.ToCString());
   }
   const Function& function =
@@ skipping 11 matching lines @@
                                    &error_message);
       }
       THR_Print("ResolveStatic error '%s': %s.\n", function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
-
 RawFunction* Resolver::ResolveStaticAllowPrivate(const Class& cls,
                                                  const String& function_name,
                                                  intptr_t type_args_len,
                                                  intptr_t num_arguments,
                                                  const Array& argument_names) {
   ASSERT(!cls.IsNull());
   if (FLAG_trace_resolving) {
     THR_Print("ResolveStaticAllowPrivate '%s'\n", function_name.ToCString());
   }
   const Function& function =
@@ skipping 12 matching lines @@
       }
       THR_Print("ResolveStaticAllowPrivate error '%s': %s.\n",
                 function_name.ToCString(), error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart