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

runtime/vm/precompiler.h

 // Copyright (c) 2015, 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_PRECOMPILER_H_
 #define RUNTIME_VM_PRECOMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/hash_map.h"
 #include "vm/hash_table.h"
@@ skipping 27 matching lines @@
  private:
   static const intptr_t kNotComputed = -1;
   static const intptr_t kNotContiguous = -2;
 
   Precompiler* precompiler_;
   Thread* thread_;
   intptr_t* lower_limits_;
   intptr_t* upper_limits_;
 };
 
-
 class SymbolKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const String* Key;
   typedef const String* Value;
   typedef const String* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->Hash(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<SymbolKeyValueTrait> SymbolSet;
 
-
 class UnlinkedCallKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const UnlinkedCall* Key;
   typedef const UnlinkedCall* Value;
   typedef const UnlinkedCall* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
@@ skipping 35 matching lines @@
     }
   }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<FunctionKeyValueTrait> FunctionSet;
 
-
 class FieldKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Field* Key;
   typedef const Field* Value;
   typedef const Field* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) {
     // We are using pointer hash for objects originating from Kernel because
     // Fasta currently does not assign any position information to them.
     if (key->kernel_offset() > 0) {
       return key->kernel_offset();
     } else {
       return key->token_pos().value();
     }
   }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<FieldKeyValueTrait> FieldSet;
 
-
 class ClassKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Class* Key;
   typedef const Class* Value;
   typedef const Class* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->token_pos().value(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<ClassKeyValueTrait> ClassSet;
 
-
 class AbstractTypeKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const AbstractType* Key;
   typedef const AbstractType* Value;
   typedef const AbstractType* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->Hash(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<AbstractTypeKeyValueTrait> AbstractTypeSet;
 
-
 class TypeArgumentsKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const TypeArguments* Key;
   typedef const TypeArguments* Value;
   typedef const TypeArguments* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->Hash(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<TypeArgumentsKeyValueTrait> TypeArgumentsSet;
 
-
 class InstanceKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Instance* Key;
   typedef const Instance* Value;
   typedef const Instance* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
   static inline intptr_t Hashcode(Key key) { return key->GetClassId(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->raw() == key->raw();
   }
 };
 
 typedef DirectChainedHashMap<InstanceKeyValueTrait> InstanceSet;
 
-
 struct FieldTypePair {
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Field* Key;
   typedef intptr_t Value;
   typedef FieldTypePair Pair;
 
   static Key KeyOf(Pair kv) { return kv.field_; }
 
   static Value ValueOf(Pair kv) { return kv.cid_; }
 
   static inline intptr_t Hashcode(Key key) { return key->token_pos().value(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair.field_->raw() == key->raw();
   }
 
   FieldTypePair(const Field* f, intptr_t cid) : field_(f), cid_(cid) {}
 
   FieldTypePair() : field_(NULL), cid_(-1) {}
 
   void Print() const;
 
   const Field* field_;
   intptr_t cid_;
 };
 
 typedef DirectChainedHashMap<FieldTypePair> FieldTypeMap;
 
-
 struct IntptrPair {
   // Typedefs needed for the DirectChainedHashMap template.
   typedef intptr_t Key;
   typedef intptr_t Value;
   typedef IntptrPair Pair;
 
   static Key KeyOf(Pair kv) { return kv.key_; }
 
   static Value ValueOf(Pair kv) { return kv.value_; }
 
   static inline intptr_t Hashcode(Key key) { return key; }
 
   static inline bool IsKeyEqual(Pair pair, Key key) { return pair.key_ == key; }
 
   IntptrPair(intptr_t key, intptr_t value) : key_(key), value_(value) {}
 
   IntptrPair() : key_(kIllegalCid), value_(kIllegalCid) {}
 
   Key key_;
   Value value_;
 };
 
 typedef DirectChainedHashMap<IntptrPair> CidMap;
 
-
 struct FunctionFeedbackKey {
   FunctionFeedbackKey() : owner_cid_(kIllegalCid), token_(0), kind_(0) {}
   FunctionFeedbackKey(intptr_t owner_cid, intptr_t token, intptr_t kind)
       : owner_cid_(owner_cid), token_(token), kind_(kind) {}
 
   intptr_t owner_cid_;
   intptr_t token_;
   intptr_t kind_;
 };
 
-
 struct FunctionFeedbackPair {
   // Typedefs needed for the DirectChainedHashMap template.
   typedef FunctionFeedbackKey Key;
   typedef ParsedJSONObject* Value;
   typedef FunctionFeedbackPair Pair;
 
   static Key KeyOf(Pair kv) { return kv.key_; }
 
   static Value ValueOf(Pair kv) { return kv.value_; }
 
   static inline intptr_t Hashcode(Key key) {
     return key.token_ ^ key.owner_cid_ ^ key.kind_;
   }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return (pair.key_.owner_cid_ == key.owner_cid_) &&
            (pair.key_.token_ == key.token_) && (pair.key_.kind_ == key.kind_);
   }
 
   FunctionFeedbackPair(Key key, Value value) : key_(key), value_(value) {}
 
   FunctionFeedbackPair() : key_(), value_(NULL) {}
 
   Key key_;
   Value value_;
 };
 
 typedef DirectChainedHashMap<FunctionFeedbackPair> FunctionFeedbackMap;
 
-
 class Precompiler : public ValueObject {
  public:
   static RawError* CompileAll(
       Dart_QualifiedFunctionName embedder_entry_points[],
       uint8_t* jit_feedback,
       intptr_t jit_feedback_length);
 
   static RawError* CompileFunction(Precompiler* precompiler,
                                    Thread* thread,
                                    Zone* zone,
@@ skipping 110 matching lines @@
   InstanceSet consts_to_retain_;
   FieldTypeMap field_type_map_;
   TypeRangeCache* type_range_cache_;
   CidMap feedback_cid_map_;
   FunctionFeedbackMap function_feedback_map_;
   Error& error_;
 
   bool get_runtime_type_is_unique_;
 };
 
-
 class FunctionsTraits {
  public:
   static const char* Name() { return "FunctionsTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     Zone* zone = Thread::Current()->zone();
     String& a_s = String::Handle(zone);
     String& b_s = String::Handle(zone);
     a_s = a.IsFunction() ? Function::Cast(a).name() : String::Cast(a).raw();
     b_s = b.IsFunction() ? Function::Cast(b).name() : String::Cast(b).raw();
     ASSERT(a_s.IsSymbol() && b_s.IsSymbol());
     return a_s.raw() == b_s.raw();
   }
   static uword Hash(const Object& obj) {
     if (obj.IsFunction()) {
       return String::Handle(Function::Cast(obj).name()).Hash();
     } else {
       ASSERT(String::Cast(obj).IsSymbol());
       return String::Cast(obj).Hash();
     }
   }
   static RawObject* NewKey(const Function& function) { return function.raw(); }
 };
 
 typedef UnorderedHashSet<FunctionsTraits> UniqueFunctionsSet;
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PRECOMPILER_H_