clang-format runtime/vm

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 51 matching lines @@
  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 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 StackmapKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Stackmap* Key;
   typedef const Stackmap* Value;
   typedef const Stackmap* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
-  static inline intptr_t Hashcode(Key key) {
-    return key->PcOffset();
-  }
+  static inline intptr_t Hashcode(Key key) { return key->PcOffset(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->Equals(*key);
   }
 };
 
 typedef DirectChainedHashMap<StackmapKeyValueTrait> StackmapSet;
 
 
 class ArrayKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Array* Key;
   typedef const Array* Value;
   typedef const Array* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
-  static inline intptr_t Hashcode(Key key) {
-    return key->Length();
-  }
+  static inline intptr_t Hashcode(Key key) { return key->Length(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     if (pair->Length() != key->Length()) {
       return false;
     }
     for (intptr_t i = 0; i < pair->Length(); i++) {
       if (pair->At(i) != key->At(i)) {
         return false;
       }
     }
     return true;
   }
 };
 
 typedef DirectChainedHashMap<ArrayKeyValueTrait> ArraySet;
 
 
 class InstructionsKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Instructions* Key;
   typedef const Instructions* Value;
   typedef const Instructions* Pair;
 
   static Key KeyOf(Pair kv) { return kv; }
 
   static Value ValueOf(Pair kv) { return kv; }
 
-  static inline intptr_t Hashcode(Key key) {
-    return key->size();
-  }
+  static inline intptr_t Hashcode(Key key) { return key->size(); }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return pair->Equals(*key);
   }
 };
 
 typedef DirectChainedHashMap<InstructionsKeyValueTrait> InstructionsSet;
 
 
 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; }
 
   static inline intptr_t Hashcode(Key key) {
     return String::Handle(key->target_name()).Hash();
   }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
     return (pair->target_name() == key->target_name()) &&
-        (pair->args_descriptor() == key->args_descriptor());
+           (pair->args_descriptor() == key->args_descriptor());
   }
 };
 
 typedef DirectChainedHashMap<UnlinkedCallKeyValueTrait> UnlinkedCallSet;
 
 
 class FunctionKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Function* Key;
   typedef const Function* Value;
   typedef const Function* 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 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<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) {
-    return key->token_pos().value();
-  }
+  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<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 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 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 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 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 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(const Field* f, intptr_t cid) : field_(f), cid_(cid) {}
 
-  FieldTypePair() : field_(NULL), cid_(-1) { }
+  FieldTypePair() : field_(NULL), cid_(-1) {}
 
   void Print() const;
 
   const Field* field_;
   intptr_t cid_;
 };
 
 typedef DirectChainedHashMap<FieldTypePair> FieldTypeMap;
 
 
@@ skipping 13 matching lines @@
   static RawObject* ExecuteOnce(SequenceNode* fragment);
 
   static RawFunction* CompileStaticInitializer(const Field& field,
                                                bool compute_type);
 
   // Returns true if get:runtimeType is not overloaded by any class.
   bool get_runtime_type_is_unique() const {
     return get_runtime_type_is_unique_;
   }
 
-  FieldTypeMap* field_type_map() {
-    return &field_type_map_;
-  }
+  FieldTypeMap* field_type_map() { return &field_type_map_; }
 
  private:
   Precompiler(Thread* thread, bool reset_fields);
 
   void DoCompileAll(Dart_QualifiedFunctionName embedder_entry_points[]);
   void ClearAllCode();
   void AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]);
   void AddEntryPoints(Dart_QualifiedFunctionName entry_points[]);
   void Iterate();
 
@@ skipping 31 matching lines @@
   void DedupStackmaps();
   void DedupLists();
   void DedupInstructions();
   void ResetPrecompilerState();
 
   void CollectDynamicFunctionNames();
 
   void PrecompileStaticInitializers();
   void PrecompileConstructors();
 
-  template<typename T>
+  template <typename T>
   class Visitor : public ValueObject {
    public:
     virtual ~Visitor() {}
     virtual void Visit(const T& obj) = 0;
   };
   typedef Visitor<Function> FunctionVisitor;
   typedef Visitor<Class> ClassVisitor;
 
   void VisitFunctions(FunctionVisitor* visitor);
   void VisitClasses(ClassVisitor* visitor);
@@ skipping 55 matching lines @@
     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();
-  }
+  static RawObject* NewKey(const Function& function) { return function.raw(); }
 };
 
 typedef UnorderedHashSet<FunctionsTraits> UniqueFunctionsSet;
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PRECOMPILER_H_