clang-format runtime/vm

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_
 
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 
@@ skipping 20 matching lines @@
   static bool IsMatch(const TreeNode* key1, const Object& b) {
     return KeyAsSmi(key1) == Smi::Cast(b).raw();
   }
   static uword Hash(const Object& obj) {
     const Smi& key = Smi::Cast(obj);
     return HashValue(key.Value());
   }
   static uword Hash(const TreeNode* key) {
     return HashValue(Smi::Value(KeyAsSmi(key)));
   }
-  static RawObject* NewKey(const TreeNode* key) {
-    return KeyAsSmi(key);
-  }
+  static RawObject* NewKey(const TreeNode* key) { return KeyAsSmi(key); }
 
  private:
-  static uword HashValue(intptr_t pos) {
-    return pos % (Smi::kMaxValue - 13);
-  }
+  static uword HashValue(intptr_t pos) { return pos % (Smi::kMaxValue - 13); }
 
   static RawSmi* KeyAsSmi(const TreeNode* key) {
     // We exploit that all [TreeNode] objects will be aligned and therefore are
     // already [Smi]s!
     return reinterpret_cast<RawSmi*>(const_cast<TreeNode*>(key));
   }
 };
 typedef UnorderedHashMap<KernelConstMapKeyEqualsTraits> KernelConstantsMap;
 
 
@@ skipping 71 matching lines @@
   // is one.
   Member* member;
 
   // The current function.
   FunctionNode* kernel_function;
 };
 
 
 class ActiveClassScope {
  public:
-  ActiveClassScope(ActiveClass* active_class, Class* kernel_class,
+  ActiveClassScope(ActiveClass* active_class,
+                   Class* kernel_class,
                    const dart::Class* klass)
       : active_class_(active_class), saved_(*active_class) {
     active_class_->kernel_class = kernel_class;
     active_class_->klass = klass;
     active_class_->member = NULL;
     active_class_->kernel_function = NULL;
   }
 
   ~ActiveClassScope() { *active_class_ = saved_; }
 
@@ skipping 35 matching lines @@
   ActiveClass saved_;
 };
 
 
 class TranslationHelper {
  public:
   TranslationHelper(dart::Thread* thread, dart::Zone* zone, Isolate* isolate)
       : thread_(thread),
         zone_(zone),
         isolate_(isolate),
-        allocation_space_(
-            thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld) {}
+        allocation_space_(thread_->IsMutatorThread() ? Heap::kNew
+                                                     : Heap::kOld) {}
   virtual ~TranslationHelper() {}
 
   Thread* thread() { return thread_; }
 
   Zone* zone() { return zone_; }
 
   Isolate* isolate() { return isolate_; }
 
   Heap::Space allocation_space() { return allocation_space_; }
 
@@ skipping 33 matching lines @@
   // A subclass overrides these when reading in the Kernel program in order to
   // support recursive type expressions (e.g. for "implements X" ...
   // annotations).
   virtual RawLibrary* LookupLibraryByKernelLibrary(Library* library);
   virtual RawClass* LookupClassByKernelClass(Class* klass);
 
   RawField* LookupFieldByKernelField(Field* field);
   RawFunction* LookupStaticMethodByKernelProcedure(Procedure* procedure);
   RawFunction* LookupConstructorByKernelConstructor(Constructor* constructor);
   dart::RawFunction* LookupConstructorByKernelConstructor(
-      const dart::Class& owner, Constructor* constructor);
+      const dart::Class& owner,
+      Constructor* constructor);
 
   dart::Type& GetCanonicalType(const dart::Class& klass);
 
   void ReportError(const char* format, ...);
   void ReportError(const Error& prev_error, const char* format, ...);
 
  private:
   // This will mangle [kernel_name] (if necessary) and make the result a symbol.
   // The result will be avilable in [name_to_modify] and it is also returned.
   dart::String& ManglePrivateName(Library* kernel_library,
@@ skipping 13 matching lines @@
 //     * T does not denote a type in scope
 //     * T refers to a type parameter in a static member
 //     * T is a parametrized Type G<T1, ...> and G is malformed
 //     * T denotes declarations from multiple imports
 //
 // Any use of a malformed type gives rise to a static warning.  A malformed
 // type is then interpreted as dynamic by the static type checker and the
 // runtime unless explicitly specified otherwise.
 class DartTypeTranslator : public DartTypeVisitor {
  public:
-  DartTypeTranslator(TranslationHelper* helper, ActiveClass* active_class,
+  DartTypeTranslator(TranslationHelper* helper,
+                     ActiveClass* active_class,
                      bool finalize = true)
       : translation_helper_(*helper),
         active_class_(active_class),
         zone_(helper->zone()),
         result_(AbstractType::Handle(helper->zone())),
         finalize_(finalize) {}
 
   // Can return a malformed type.
   AbstractType& TranslateType(DartType* node);
 
@@ skipping 14 matching lines @@
 
   virtual void VisitInterfaceType(InterfaceType* node);
 
   virtual void VisitDynamicType(DynamicType* node);
 
   virtual void VisitVoidType(VoidType* node);
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& TranslateInstantiatedTypeArguments(
-      const dart::Class& receiver_class, DartType** receiver_type_arguments,
+      const dart::Class& receiver_class,
+      DartType** receiver_type_arguments,
       intptr_t length);
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& TranslateTypeArguments(DartType** dart_types,
                                               intptr_t length);
 
   const Type& ReceiverType(const dart::Class& klass);
 
  private:
@@ skipping 20 matching lines @@
 //      f(a, [b = <expr>])
 //      f(a, {b: <expr>})
 //
 //   * constant values to compare in a [SwitchCase]
 //      case <expr>:
 //
 // In all cases `<expr>` must be recursively evaluated and canonicalized at
 // compile-time.
 class ConstantEvaluator : public ExpressionVisitor {
  public:
-  ConstantEvaluator(FlowGraphBuilder* builder, Zone* zone, TranslationHelper* h,
+  ConstantEvaluator(FlowGraphBuilder* builder,
+                    Zone* zone,
+                    TranslationHelper* h,
                     DartTypeTranslator* type_translator);
   virtual ~ConstantEvaluator() {}
 
   Instance& EvaluateExpression(Expression* node);
   Object& EvaluateExpressionSafe(Expression* node);
   Instance& EvaluateConstructorInvocation(ConstructorInvocation* node);
   Instance& EvaluateListLiteral(ListLiteral* node);
   Instance& EvaluateMapLiteral(MapLiteral* node);
 
   virtual void VisitDefaultExpression(Expression* node) { UNREACHABLE(); }
@@ skipping 24 matching lines @@
  private:
   // This will translate type arguments form [kernel_arguments].  If no type
   // arguments are passed and the [target] is a factory then the null type
   // argument array will be returned.
   //
   // If none of these cases apply, NULL will be returned.
   const TypeArguments* TranslateTypeArguments(const Function& target,
                                               dart::Class* target_klass,
                                               Arguments* kernel_arguments);
 
-  const Object& RunFunction(const Function& function, Arguments* arguments,
+  const Object& RunFunction(const Function& function,
+                            Arguments* arguments,
                             const Instance* receiver = NULL,
                             const TypeArguments* type_args = NULL);
 
-  const Object& RunFunction(const Function& function, const Array& arguments,
+  const Object& RunFunction(const Function& function,
+                            const Array& arguments,
                             const Array& names);
 
   RawObject* EvaluateConstConstructorCall(const dart::Class& type_class,
                                           const TypeArguments& type_arguments,
                                           const Function& constructor,
                                           const Object& argument);
 
   // TODO(27590): Instead of using [dart::kernel::TreeNode]s as keys we
   // should use [TokenPosition]s as well as the existing functionality in
   // `Parser::CacheConstantValue`.
@@ skipping 13 matching lines @@
 
 struct FunctionScope {
   FunctionNode* function;
   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) {}
+      : 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) {}
 
   Map<VariableDeclaration, LocalVariable*> locals;
   Map<TreeNode, LocalScope*> scopes;
   GrowableArray<FunctionScope> function_scopes;
 
   // Only non-NULL for instance functions.
   LocalVariable* this_variable;
 
   // Only non-NULL for factory constructor functions.
   LocalVariable* type_arguments_variable;
@@ skipping 78 matching lines @@
   void ExitScope();
 
   const Type& TranslateVariableType(VariableDeclaration* variable);
   LocalVariable* MakeVariable(const dart::String& name,
                               const AbstractType& type);
 
   void AddParameters(FunctionNode* function, intptr_t pos = 0);
   void AddParameter(VariableDeclaration* declaration, intptr_t pos);
   void AddVariable(VariableDeclaration* declaration);
   void AddExceptionVariable(GrowableArray<LocalVariable*>* variables,
-                            const char* prefix, intptr_t nesting_depth);
+                            const char* prefix,
+                            intptr_t nesting_depth);
   void AddTryVariables();
   void AddCatchVariables();
   void AddIteratorVariable();
   void AddSwitchVariable();
 
   // Record an assignment or reference to a variable.  If the occurrence is
   // in a nested function, ensure that the variable is handled properly as a
   // captured variable.
   void LookupVariable(VariableDeclaration* declaration);
 
@@ skipping 36 matching lines @@
   LocalScope* current_function_scope_;
   LocalScope* scope_;
   DepthState depth_;
 
   intptr_t name_index_;
 };
 
 
 class FlowGraphBuilder : public TreeVisitor {
  public:
-  FlowGraphBuilder(TreeNode* node, ParsedFunction* parsed_function,
+  FlowGraphBuilder(TreeNode* node,
+                   ParsedFunction* parsed_function,
                    const ZoneGrowableArray<const ICData*>& ic_data_array,
-                   InlineExitCollector* exit_collector, intptr_t osr_id,
+                   InlineExitCollector* exit_collector,
+                   intptr_t osr_id,
                    intptr_t first_block_id = 1);
   virtual ~FlowGraphBuilder();
 
   FlowGraph* BuildGraph();
 
   virtual void VisitDefaultTreeNode(TreeNode* node) { UNREACHABLE(); }
 
   virtual void VisitInvalidExpression(InvalidExpression* node);
   virtual void VisitNullLiteral(NullLiteral* node);
   virtual void VisitBoolLiteral(BoolLiteral* node);
@@ skipping 119 matching lines @@
                                TargetEntryInstr** otherwise_entry);
   Fragment CatchBlockEntry(const Array& handler_types, intptr_t handler_index);
   Fragment TryCatch(int try_handler_index);
   Fragment CheckStackOverflowInPrologue();
   Fragment CheckStackOverflow();
   Fragment CloneContext();
   Fragment Constant(const Object& value);
   Fragment CreateArray();
   Fragment Goto(JoinEntryInstr* destination);
   Fragment IntConstant(int64_t value);
-  Fragment InstanceCall(const dart::String& name, Token::Kind kind,
-                        intptr_t argument_count, intptr_t num_args_checked = 1);
-  Fragment InstanceCall(const dart::String& name, Token::Kind kind,
-                        intptr_t argument_count, const Array& argument_names,
+  Fragment InstanceCall(const dart::String& name,
+                        Token::Kind kind,
+                        intptr_t argument_count,
+                        intptr_t num_args_checked = 1);
+  Fragment InstanceCall(const dart::String& name,
+                        Token::Kind kind,
+                        intptr_t argument_count,
+                        const Array& argument_names,
                         intptr_t num_args_checked = 1);
   Fragment ClosureCall(int argument_count, const Array& argument_names);
   Fragment ThrowException();
   Fragment RethrowException(int catch_try_index);
   Fragment LoadClassId();
   Fragment LoadField(const dart::Field& field);
   Fragment LoadField(intptr_t offset, intptr_t class_id = kDynamicCid);
-  Fragment LoadNativeField(MethodRecognizer::Kind kind, intptr_t offset,
-                           const Type& type, intptr_t class_id,
+  Fragment LoadNativeField(MethodRecognizer::Kind kind,
+                           intptr_t offset,
+                           const Type& type,
+                           intptr_t class_id,
                            bool is_immutable = false);
   Fragment LoadLocal(LocalVariable* variable);
   Fragment InitStaticField(const dart::Field& field);
   Fragment LoadStaticField();
   Fragment NullConstant();
   Fragment NativeCall(const dart::String* name, const Function* function);
   Fragment PushArgument();
   Fragment Return();
   Fragment StaticCall(const Function& target, intptr_t argument_count);
-  Fragment StaticCall(const Function& target, intptr_t argument_count,
+  Fragment StaticCall(const Function& target,
+                      intptr_t argument_count,
                       const Array& argument_names);
   Fragment StoreIndexed(intptr_t class_id);
   Fragment StoreInstanceFieldGuarded(const dart::Field& field);
   Fragment StoreInstanceField(
       const dart::Field& field,
       StoreBarrierType emit_store_barrier = kEmitStoreBarrier);
   Fragment StoreInstanceField(
       intptr_t offset,
       StoreBarrierType emit_store_barrier = kEmitStoreBarrier);
   Fragment StoreLocal(LocalVariable* variable);
   Fragment StoreStaticField(const dart::Field& field);
   Fragment StringInterpolate();
   Fragment ThrowTypeError();
   Fragment ThrowNoSuchMethodError();
   Fragment BuildImplicitClosureCreation(const Function& target);
   Fragment GuardFieldLength(const dart::Field& field, intptr_t deopt_id);
   Fragment GuardFieldClass(const dart::Field& field, intptr_t deopt_id);
 
   dart::RawFunction* LookupMethodByMember(Member* target,
                                           const dart::String& method_name);
 
   LocalVariable* MakeTemporary();
   LocalVariable* MakeNonTemporary(const dart::String& symbol);
 
   intptr_t CurrentTryIndex();
   intptr_t AllocateTryIndex() { return next_used_try_index_++; }
 
   void AddVariable(VariableDeclaration* declaration, LocalVariable* variable);
-  void AddParameter(VariableDeclaration* declaration, LocalVariable* variable,
+  void AddParameter(VariableDeclaration* declaration,
+                    LocalVariable* variable,
                     intptr_t pos);
   dart::LocalVariable* LookupVariable(VariableDeclaration* var);
 
   void SetTempIndex(Definition* definition);
 
   void Push(Definition* definition);
   Value* Pop();
   Fragment Drop();
 
   bool IsInlining() { return exit_collector_ != NULL; }
@@ skipping 89 matching lines @@
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_