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

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/kernel_binary.h"
@@ skipping 14 matching lines @@
 
 class SimpleExpressionConverter {
  public:
   SimpleExpressionConverter(TranslationHelper* helper,
                             StreamingFlowGraphBuilder* builder)
       : translation_helper_(*helper),
         zone_(translation_helper_.zone()),
         simple_value_(NULL),
         builder_(builder) {}
 
-
   bool IsSimple(intptr_t kernel_offset) {
     AlternativeReadingScope alt(builder_->reader_, kernel_offset);
     uint8_t payload = 0;
     Tag tag = builder_->ReadTag(&payload);  // read tag.
     switch (tag) {
       case kBigIntLiteral:
         simple_value_ = &Integer::ZoneHandle(
             Z, Integer::New(
                    H.DartString(builder_->ReadStringReference(),
                                 Heap::kOld)));  // read index into string table.
@@ skipping 45 matching lines @@
   const dart::Instance& SimpleValue() { return *simple_value_; }
   dart::Zone* zone() const { return zone_; }
 
  private:
   TranslationHelper& translation_helper_;
   dart::Zone* zone_;
   dart::Instance* simple_value_;
   StreamingFlowGraphBuilder* builder_;
 };
 
-
 RawArray* KernelReader::MakeFunctionsArray() {
   const intptr_t len = functions_.length();
   const Array& res = Array::Handle(zone_, Array::New(len, Heap::kOld));
   for (intptr_t i = 0; i < len; i++) {
     res.SetAt(i, *functions_[i]);
   }
   return res.raw();
 }
 
-
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
     NameIndex library) {
   return reader_->LookupLibrary(library).raw();
 }
 
-
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(NameIndex klass) {
   return reader_->LookupClass(klass).raw();
 }
 
-
 KernelReader::KernelReader(Program* program)
     : program_(program),
       thread_(dart::Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_),
       builder_(&translation_helper_,
                zone_,
                program_->kernel_data(),
@@ skipping 33 matching lines @@
       Z, TypedData::New(kTypedDataUint32ArrayCid, count, Heap::kOld));
   for (intptr_t i = 0; i < count; ++i) {
     names.SetUint32(i << 2, reader.ReadUInt());
   }
 
   H.SetStringOffsets(offsets);
   H.SetStringData(data);
   H.SetCanonicalNames(names);
 }
 
-
 Object& KernelReader::ReadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     intptr_t length = program_->library_count();
     for (intptr_t i = 0; i < length; i++) {
       ReadLibrary(library_offset(i));
     }
 
     for (intptr_t i = 0; i < length; i++) {
       dart::Library& library = LookupLibrary(library_canonical_name(i));
@@ skipping 18 matching lines @@
   }
 
   // Either class finalization failed or we caught a compile error.
   // In both cases sticky error would be set.
   Error& error = Error::Handle(Z);
   error = thread_->sticky_error();
   thread_->clear_sticky_error();
   return error;
 }
 
-
 void KernelReader::ReadLibrary(intptr_t kernel_offset) {
   builder_.SetOffset(kernel_offset);
   LibraryHelper library_helper(&builder_);
   library_helper.ReadUntilIncluding(LibraryHelper::kCanonicalName);
   dart::Library& library = LookupLibrary(library_helper.canonical_name_);
   if (library.Loaded()) return;
 
   library_helper.ReadUntilIncluding(LibraryHelper::kName);
   library.SetName(H.DartSymbol(library_helper.name_index_));
 
@@ skipping 69 matching lines @@
   intptr_t procedure_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < procedure_count; ++i) {
     ReadProcedure(library, toplevel_class, false);
   }
 
   toplevel_class.SetFunctions(Array::Handle(MakeFunctionsArray()));
 
   classes.Add(toplevel_class, Heap::kOld);
 }
 
-
 void KernelReader::ReadPreliminaryClass(dart::Class* klass,
                                         ClassHelper* class_helper,
                                         intptr_t type_parameter_count) {
   // Note: This assumes that ClassHelper is exactly at the position where
   // the length of the type parameters have been read, and that the order in
   // the binary is as follows: [...], kTypeParameters, kSuperClass, kMixinType,
   // kImplementedClasses, [...].
 
   // First setup the type parameters, so if any of the following code uses it
   // (in a recursive way) we're fine.
@@ skipping 62 matching lines @@
         T.BuildTypeWithoutFinalization();  // read ith type.
     if (type.IsMalformed()) H.ReportError("Malformed interface type.");
     interfaces.SetAt(i, type);
   }
   class_helper->SetJustRead(ClassHelper::kImplementedClasses);
   klass->set_interfaces(interfaces);
 
   if (class_helper->is_abstract_) klass->set_is_abstract();
 }
 
-
 dart::Class& KernelReader::ReadClass(const dart::Library& library,
                                      const dart::Class& toplevel_class) {
   ClassHelper class_helper(&builder_);
   intptr_t class_offset = builder_.ReaderOffset();
   class_helper.ReadUntilIncluding(ClassHelper::kCanonicalName);
   dart::Class& klass = LookupClass(class_helper.canonical_name_);
 
   // The class needs to have a script because all the functions in the class
   // will inherit it.  The predicate Function::IsOptimizable uses the absence of
   // a script to detect test functions that should not be optimized.
@@ skipping 133 matching lines @@
   if (FLAG_enable_mirrors && class_helper.annotation_count_ > 0) {
     library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
                              class_offset);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kEnd);
 
   return klass;
 }
 
-
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  bool in_class) {
   intptr_t procedure_offset = builder_.ReaderOffset();
   ProcedureHelper procedure_helper(&builder_);
 
   bool member_is_procedure = false;
   bool is_factory_procedure = false;
   intptr_t member_type_parameters = 0;
   intptr_t member_type_parameters_offset_start = -1;
@@ skipping 252 matching lines @@
                          script_class, field_helper->position_));
     functions_.Add(&setter);
     setter.set_end_token_pos(field_helper->end_position_);
     setter.set_kernel_offset(field_offset);
     setter.set_result_type(Object::void_type());
     setter.set_is_debuggable(false);
     SetupFieldAccessorFunction(klass, setter);
   }
 }
 
-
 void KernelReader::SetupFieldAccessorFunction(const dart::Class& klass,
                                               const dart::Function& function) {
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   intptr_t parameter_count = (is_method ? 1 : 0) + (is_setter ? 1 : 0);
 
   function.SetNumOptionalParameters(0, false);
   function.set_num_fixed_parameters(parameter_count);
   function.set_parameter_types(
       Array::Handle(Z, Array::New(parameter_count, Heap::kOld)));
   function.set_parameter_names(
       Array::Handle(Z, Array::New(parameter_count, Heap::kOld)));
 
   intptr_t pos = 0;
   if (is_method) {
     function.SetParameterTypeAt(pos, T.ReceiverType(klass));
     function.SetParameterNameAt(pos, Symbols::This());
     pos++;
   }
   if (is_setter) {
     function.SetParameterTypeAt(pos, AbstractType::dynamic_type());
     function.SetParameterNameAt(pos, Symbols::Value());
     pos++;
   }
 }
 
-
 dart::Library& KernelReader::LookupLibrary(NameIndex library) {
   dart::Library* handle = NULL;
   if (!libraries_.Lookup(library, &handle)) {
     const dart::String& url = H.DartSymbol(H.CanonicalNameString(library));
     handle =
         &dart::Library::Handle(Z, dart::Library::LookupLibrary(thread_, url));
     if (handle->IsNull()) {
       *handle = dart::Library::New(url);
       handle->Register(thread_);
     }
     ASSERT(!handle->IsNull());
     libraries_.Insert(library, handle);
   }
   return *handle;
 }
 
-
 dart::Class& KernelReader::LookupClass(NameIndex klass) {
   dart::Class* handle = NULL;
   if (!classes_.Lookup(klass, &handle)) {
     dart::Library& library = LookupLibrary(H.CanonicalNameParent(klass));
     const dart::String& name = H.DartClassName(klass);
     handle = &dart::Class::Handle(Z, library.LookupClass(name));
     if (handle->IsNull()) {
       *handle = dart::Class::New(library, name, Script::Handle(Z),
                                  TokenPosition::kNoSource);
       library.AddClass(*handle);
     }
     // Insert the class in the cache before calling ReadPreliminaryClass so
     // we do not risk allocating the class again by calling LookupClass
     // recursively from ReadPreliminaryClass for the same class.
     classes_.Insert(klass, handle);
   }
   return *handle;
 }
 
-
 RawFunction::Kind KernelReader::GetFunctionType(
     Procedure::ProcedureKind procedure_kind) {
   intptr_t lookuptable[] = {
       RawFunction::kRegularFunction,  // Procedure::kMethod
       RawFunction::kGetterFunction,   // Procedure::kGetter
       RawFunction::kSetterFunction,   // Procedure::kSetter
       RawFunction::kRegularFunction,  // Procedure::kOperator
       RawFunction::kConstructor,      // Procedure::kFactory
   };
   intptr_t kind = static_cast<int>(procedure_kind);
   if (kind == Procedure::kIncompleteProcedure) {
     return RawFunction::kSignatureFunction;
   } else {
     ASSERT(0 <= kind && kind <= Procedure::kFactory);
     return static_cast<RawFunction::Kind>(lookuptable[kind]);
   }
 }
 
-
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone,
                                             const dart::Field& field) {
   Thread* thread = Thread::Current();
 
   dart::String& init_name = dart::String::Handle(zone, field.name());
   init_name = Symbols::FromConcat(thread, Symbols::InitPrefix(), init_name);
 
   // Create a static initializer.
   const Object& owner = Object::Handle(field.RawOwner());
   const Function& initializer_fun = Function::ZoneHandle(
       zone,
       dart::Function::New(init_name, RawFunction::kImplicitStaticFinalGetter,
                           true,   // is_static
                           false,  // is_const
                           false,  // is_abstract
                           false,  // is_external
                           false,  // is_native
                           owner, TokenPosition::kNoSource));
   initializer_fun.set_kernel_offset(field.kernel_offset());
   initializer_fun.set_result_type(AbstractType::Handle(zone, field.type()));
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
-
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)