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

runtime/vm/compilation_trace.cc

 // Copyright (c) 2017, 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/compilation_trace.h"
 
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 CompilationTraceSaver::CompilationTraceSaver(Zone* zone)
     : buf_(zone, 4 * KB),
       func_name_(String::Handle(zone)),
       cls_(Class::Handle(zone)),
       cls_name_(String::Handle(zone)),
       lib_(Library::Handle(zone)),
       uri_(String::Handle(zone)) {}
 
-
 void CompilationTraceSaver::Visit(const Function& function) {
   if (!function.HasCode()) {
     return;  // Not compiled.
   }
   if (function.parent_function() != Function::null()) {
     // Lookup works poorly for local functions. We compile all local functions
     // in a compiled function instead.
     return;
   }
 
   func_name_ = function.name();
   func_name_ = String::RemovePrivateKey(func_name_);
   cls_ = function.Owner();
   cls_name_ = cls_.Name();
   cls_name_ = String::RemovePrivateKey(cls_name_);
   lib_ = cls_.library();
   uri_ = lib_.url();
   buf_.Printf("%s,%s,%s\n", uri_.ToCString(), cls_name_.ToCString(),
               func_name_.ToCString());
 }
 
-
 CompilationTraceLoader::CompilationTraceLoader(Thread* thread)
     : thread_(thread),
       zone_(thread->zone()),
       uri_(String::Handle(zone_)),
       class_name_(String::Handle(zone_)),
       function_name_(String::Handle(zone_)),
       function_name2_(String::Handle(zone_)),
       lib_(Library::Handle(zone_)),
       cls_(Class::Handle(zone_)),
       function_(Function::Handle(zone_)),
       function2_(Function::Handle(zone_)),
       field_(Field::Handle(zone_)),
       error_(Object::Handle(zone_)) {}
 
-
 static char* FindCharacter(char* str, char goal, char* limit) {
   while (str < limit) {
     if (*str == goal) {
       return str;
     }
     str++;
   }
   return NULL;
 }
 
-
 RawObject* CompilationTraceLoader::CompileTrace(uint8_t* buffer,
                                                 intptr_t size) {
   // First compile functions named in the trace.
   char* cursor = reinterpret_cast<char*>(buffer);
   char* limit = cursor + size;
   while (cursor < limit) {
     char* uri = cursor;
     char* comma1 = FindCharacter(uri, ',', limit);
     if (comma1 == NULL) {
       break;
@@ skipping 48 matching lines @@
       error_ = CompileFunction(function_);
       if (error_.IsError()) {
         return error_.raw();
       }
     }
   }
 
   return Object::null();
 }
 
-
 // Use a fuzzy match to find the right function to compile. This allows a
 // compilation trace to remain mostly valid in the face of program changes, and
 // deals with implicit/dispatcher functions that don't have proper names.
 //  - Ignore private name mangling
 //  - If looking for a getter and we only have the corresponding regular method,
 //    compile the regular method, create its implicit closure and compile that.
 //  - If looking for a regular method and we only have the corresponding getter,
 //    compile the getter, create its method extractor and compile that.
 //  - If looking for a getter and we only have a const field, evaluate the const
 //    field.
@@ skipping 81 matching lines @@
       error_ = CompileFunction(function_);
       if (error_.IsError()) {
         return error_.raw();
       }
     }
   }
 
   return Object::null();
 }
 
-
 RawObject* CompilationTraceLoader::CompileFunction(const Function& function) {
   if (function.is_abstract()) {
     return Object::null();
   }
   return Compiler::CompileFunction(thread_, function);
 }
 
-
 RawObject* CompilationTraceLoader::EvaluateInitializer(const Field& field) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     field_.EvaluateInitializer();
   } else {
     Thread* thread = Thread::Current();
     const Error& error = Error::Handle(thread->sticky_error());
     thread->clear_sticky_error();
     return error.raw();
   }
   return Object::null();
 }
 
 }  // namespace dart