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

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 33 matching lines @@
  private:
   static uword HashValue(intptr_t pos) { return pos % (Smi::kMaxValue - 13); }
 
   static RawSmi* KeyAsSmi(const intptr_t key) {
     ASSERT(key >= 0);
     return Smi::New(key);
   }
 };
 typedef UnorderedHashMap<KernelConstMapKeyEqualsTraits> KernelConstantsMap;
 
-
 template <typename K, typename V>
 class Map : public DirectChainedHashMap<RawPointerKeyValueTrait<K, V> > {
  public:
   typedef typename RawPointerKeyValueTrait<K, V>::Key Key;
   typedef typename RawPointerKeyValueTrait<K, V>::Value Value;
   typedef typename RawPointerKeyValueTrait<K, V>::Pair Pair;
 
   inline void Insert(const Key& key, const Value& value) {
     Pair pair(key, value);
     DirectChainedHashMap<RawPointerKeyValueTrait<K, V> >::Insert(pair);
   }
 
   inline V Lookup(const Key& key) {
     Pair* pair =
         DirectChainedHashMap<RawPointerKeyValueTrait<K, V> >::Lookup(key);
     if (pair == NULL) {
       return V();
     } else {
       return pair->value;
     }
   }
 
   inline Pair* LookupPair(const Key& key) {
     return DirectChainedHashMap<RawPointerKeyValueTrait<K, V> >::Lookup(key);
   }
 };
 
-
 template <typename V>
 class IntKeyRawPointerValueTrait {
  public:
   typedef intptr_t Key;
   typedef V Value;
 
   struct Pair {
     Key key;
     Value value;
     Pair() : key(NULL), value() {}
@@ skipping 56 matching lines @@
       return pair->value;
     }
   }
 
   inline Pair* LookupPair(const Key& key) {
     return MallocDirectChainedHashMap<RawPointerKeyValueTrait<K, V> >::Lookup(
         key);
   }
 };
 
-
 class BreakableBlock;
 class CatchBlock;
 class FlowGraphBuilder;
 class SwitchBlock;
 class TryCatchBlock;
 class TryFinallyBlock;
 
 class Fragment {
  public:
   Instruction* entry;
@@ skipping 14 matching lines @@
   Fragment& operator<<=(Instruction* next);
 
   Fragment closed();
 };
 
 Fragment operator+(const Fragment& first, const Fragment& second);
 Fragment operator<<(const Fragment& fragment, Instruction* next);
 
 typedef ZoneGrowableArray<PushArgumentInstr*>* ArgumentArray;
 
-
 class ActiveClass {
  public:
   ActiveClass()
       : kernel_class(NULL),
         class_type_parameters(0),
         class_type_parameters_offset_start(-1),
         klass(NULL),
         member_is_procedure(false),
         member_is_factory_procedure(false),
         member_type_parameters(0),
         member_type_parameters_offset_start(-1) {}
 
   // The current enclosing kernel class (if available, otherwise NULL).
   Class* kernel_class;
   intptr_t class_type_parameters;
   intptr_t class_type_parameters_offset_start;
 
   // The current enclosing class (or the library top-level class).  When this is
   // a library's top-level class, the kernel_class will be NULL.
   const dart::Class* klass;
 
   bool member_is_procedure;
   bool member_is_factory_procedure;
   intptr_t member_type_parameters;
   intptr_t member_type_parameters_offset_start;
 };
 
-
 class ActiveClassScope {
  public:
   ActiveClassScope(ActiveClass* active_class,
                    intptr_t class_type_parameters,
                    intptr_t class_type_parameters_offset_start,
                    const dart::Class* klass)
       : active_class_(active_class), saved_(*active_class) {
     active_class_->kernel_class = NULL;
     active_class_->class_type_parameters = class_type_parameters;
     active_class_->class_type_parameters_offset_start =
         class_type_parameters_offset_start;
     active_class_->klass = klass;
   }
 
   ~ActiveClassScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
-
 class ActiveMemberScope {
  public:
   ActiveMemberScope(ActiveClass* active_class,
                     bool member_is_procedure,
                     bool member_is_factory_procedure,
                     intptr_t member_type_parameters,
                     intptr_t member_type_parameters_offset_start)
       : active_class_(active_class), saved_(*active_class) {
     // The class and kernel_class is inherited.
     active_class_->member_is_procedure = member_is_procedure;
     active_class_->member_is_factory_procedure = member_is_factory_procedure;
     active_class_->member_type_parameters = member_type_parameters;
     active_class_->member_type_parameters_offset_start =
         member_type_parameters_offset_start;
   }
 
   ~ActiveMemberScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
-
 class TranslationHelper {
  public:
   explicit TranslationHelper(dart::Thread* thread);
   virtual ~TranslationHelper() {}
 
   Thread* thread() { return thread_; }
 
   Zone* zone() { return zone_; }
 
   Isolate* isolate() { return isolate_; }
@@ skipping 98 matching lines @@
 
  private:
   // This will mangle [name_to_modify] if necessary and make the result a symbol
   // if asked.  The result will be available in [name_to_modify] and it is also
   // returned.  If the name is private, the canonical name [parent] will be used
   // to get the import URI of the library where the name is visible.
   dart::String& ManglePrivateName(NameIndex parent,
                                   dart::String* name_to_modify,
                                   bool symbolize = true);
 
-
   Thread* thread_;
   Zone* zone_;
   Isolate* isolate_;
   Heap::Space allocation_space_;
 
   TypedData& string_offsets_;
   TypedData& string_data_;
   TypedData& canonical_names_;
 };
 
-
 struct FunctionScope {
   intptr_t kernel_offset;
   LocalScope* scope;
 };
 
-
 class ScopeBuildingResult : public ZoneAllocated {
  public:
   ScopeBuildingResult()
       : this_variable(NULL),
         type_arguments_variable(NULL),
         switch_variable(NULL),
         finally_return_variable(NULL),
         setter_value(NULL),
         yield_jump_variable(NULL),
         yield_context_variable(NULL) {}
@@ skipping 30 matching lines @@
   // Variables used in exception handlers, one per exception handler nesting
   // level.
   GrowableArray<LocalVariable*> exception_variables;
   GrowableArray<LocalVariable*> stack_trace_variables;
   GrowableArray<LocalVariable*> catch_context_variables;
 
   // For-in iterators, one per for-in nesting level.
   GrowableArray<LocalVariable*> iterator_variables;
 };
 
-
 struct YieldContinuation {
   Instruction* entry;
   intptr_t try_index;
 
   YieldContinuation(Instruction* entry, intptr_t try_index)
       : entry(entry), try_index(try_index) {}
 
   YieldContinuation()
       : entry(NULL), try_index(CatchClauseNode::kInvalidTryIndex) {}
 };
@@ skipping 220 matching lines @@
   LocalVariable* CurrentException() {
     return scopes_->exception_variables[catch_depth_ - 1];
   }
   LocalVariable* CurrentStackTrace() {
     return scopes_->stack_trace_variables[catch_depth_ - 1];
   }
   LocalVariable* CurrentCatchContext() {
     return scopes_->catch_context_variables[try_depth_];
   }
 
-
   // A chained list of breakable blocks. Chaining and lookup is done by the
   // [BreakableBlock] class.
   BreakableBlock* breakable_block_;
 
   // A chained list of switch blocks. Chaining and lookup is done by the
   // [SwitchBlock] class.
   SwitchBlock* switch_block_;
 
   // A chained list of try-finally blocks. Chaining and lookup is done by the
   // [TryFinallyBlock] class.
@@ skipping 15 matching lines @@
   friend class BreakableBlock;
   friend class CatchBlock;
   friend class ConstantEvaluator;
   friend class StreamingFlowGraphBuilder;
   friend class ScopeBuilder;
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
-
 class SwitchBlock {
  public:
   SwitchBlock(FlowGraphBuilder* builder, intptr_t case_count)
       : builder_(builder),
         outer_(builder->switch_block_),
         outer_finally_(builder->try_finally_block_),
         case_count_(case_count),
         context_depth_(builder->context_depth_),
         try_index_(builder->CurrentTryIndex()) {
     builder_->switch_block_ = this;
@@ skipping 61 matching lines @@
 
   IntMap<JoinEntryInstr*> destinations_;
 
   TryFinallyBlock* outer_finally_;
   intptr_t case_count_;
   intptr_t depth_;
   intptr_t context_depth_;
   intptr_t try_index_;
 };
 
-
 class TryCatchBlock {
  public:
   explicit TryCatchBlock(FlowGraphBuilder* builder,
                          intptr_t try_handler_index = -1)
       : builder_(builder),
         outer_(builder->try_catch_block_),
         try_index_(try_handler_index) {
     if (try_index_ == -1) try_index_ = builder->AllocateTryIndex();
     builder->try_catch_block_ = this;
   }
   ~TryCatchBlock() { builder_->try_catch_block_ = outer_; }
 
   intptr_t try_index() { return try_index_; }
   TryCatchBlock* outer() const { return outer_; }
 
  private:
   FlowGraphBuilder* builder_;
   TryCatchBlock* outer_;
   intptr_t try_index_;
 };
 
-
 class TryFinallyBlock {
  public:
-  TryFinallyBlock(FlowGraphBuilder* builder,
-                  intptr_t finalizer_kernel_offset)
+  TryFinallyBlock(FlowGraphBuilder* builder, intptr_t finalizer_kernel_offset)
       : builder_(builder),
         outer_(builder->try_finally_block_),
         finalizer_kernel_offset_(finalizer_kernel_offset),
         context_depth_(builder->context_depth_),
         // Finalizers are executed outside of the try block hence
         // try depth of finalizers are one less than current try
         // depth.
         try_depth_(builder->try_depth_ - 1),
         try_index_(builder_->CurrentTryIndex()) {
     builder_->try_finally_block_ = this;
   }
   ~TryFinallyBlock() { builder_->try_finally_block_ = outer_; }
 
   intptr_t finalizer_kernel_offset() const { return finalizer_kernel_offset_; }
   intptr_t context_depth() const { return context_depth_; }
   intptr_t try_depth() const { return try_depth_; }
   intptr_t try_index() const { return try_index_; }
   TryFinallyBlock* outer() const { return outer_; }
 
  private:
   FlowGraphBuilder* const builder_;
   TryFinallyBlock* const outer_;
   intptr_t finalizer_kernel_offset_;
   const intptr_t context_depth_;
   const intptr_t try_depth_;
   const intptr_t try_index_;
 };
 
-
 class BreakableBlock {
  public:
   explicit BreakableBlock(FlowGraphBuilder* builder)
       : builder_(builder),
         outer_(builder->breakable_block_),
         destination_(NULL),
         outer_finally_(builder->try_finally_block_),
         context_depth_(builder->context_depth_),
         try_index_(builder->CurrentTryIndex()) {
     if (builder_->breakable_block_ == NULL) {
@@ skipping 59 matching lines @@
   intptr_t catch_try_index() { return catch_try_index_; }
 
  private:
   FlowGraphBuilder* builder_;
   CatchBlock* outer_;
   LocalVariable* exception_var_;
   LocalVariable* stack_trace_var_;
   intptr_t catch_try_index_;
 };
 
-
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 void CollectTokenPositionsFor(const Script& script);
 String& GetSourceFor(const Script& script);
 Array& GetLineStartsFor(const Script& script);
 
-
 }  // namespace kernel
 }  // namespace dart
 
 #else  // !defined(DART_PRECOMPILED_RUNTIME)
 
+#include "vm/kernel.h"
 #include "vm/object.h"
-#include "vm/kernel.h"
 
 namespace dart {
 namespace kernel {
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_