clang-format runtime/vm

runtime/vm/kernel.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_H_
 #define RUNTIME_VM_KERNEL_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
 
-#define KERNEL_NODES_DO(M) \
-  M(Name)                  \
-  M(InferredValue)         \
-  M(DartType)              \
-  M(InvalidType)           \
-  M(DynamicType)           \
-  M(VoidType)              \
-  M(InterfaceType)         \
-  M(FunctionType)          \
+#define KERNEL_NODES_DO(M)                                                     \
+  M(Name)                                                                      \
+  M(InferredValue)                                                             \
+  M(DartType)                                                                  \
+  M(InvalidType)                                                               \
+  M(DynamicType)                                                               \
+  M(VoidType)                                                                  \
+  M(InterfaceType)                                                             \
+  M(FunctionType)                                                              \
   M(TypeParameterType)
 
-#define KERNEL_TREE_NODES_DO(M) \
-  M(Library)                    \
-  M(Class)                      \
-  M(NormalClass)                \
-  M(MixinClass)                 \
-  M(Member)                     \
-  M(Field)                      \
-  M(Constructor)                \
-  M(Procedure)                  \
-  M(Initializer)                \
-  M(InvalidInitializer)         \
-  M(FieldInitializer)           \
-  M(SuperInitializer)           \
-  M(RedirectingInitializer)     \
-  M(LocalInitializer)           \
-  M(FunctionNode)               \
-  M(Expression)                 \
-  M(InvalidExpression)          \
-  M(VariableGet)                \
-  M(VariableSet)                \
-  M(PropertyGet)                \
-  M(PropertySet)                \
-  M(DirectPropertyGet)          \
-  M(DirectPropertySet)          \
-  M(StaticGet)                  \
-  M(StaticSet)                  \
-  M(Arguments)                  \
-  M(NamedExpression)            \
-  M(MethodInvocation)           \
-  M(DirectMethodInvocation)     \
-  M(StaticInvocation)           \
-  M(ConstructorInvocation)      \
-  M(Not)                        \
-  M(LogicalExpression)          \
-  M(ConditionalExpression)      \
-  M(StringConcatenation)        \
-  M(IsExpression)               \
-  M(AsExpression)               \
-  M(BasicLiteral)               \
-  M(StringLiteral)              \
-  M(BigintLiteral)              \
-  M(IntLiteral)                 \
-  M(DoubleLiteral)              \
-  M(BoolLiteral)                \
-  M(NullLiteral)                \
-  M(SymbolLiteral)              \
-  M(TypeLiteral)                \
-  M(ThisExpression)             \
-  M(Rethrow)                    \
-  M(Throw)                      \
-  M(ListLiteral)                \
-  M(MapLiteral)                 \
-  M(MapEntry)                   \
-  M(AwaitExpression)            \
-  M(FunctionExpression)         \
-  M(Let)                        \
-  M(BlockExpression)            \
-  M(Statement)                  \
-  M(InvalidStatement)           \
-  M(ExpressionStatement)        \
-  M(Block)                      \
-  M(EmptyStatement)             \
-  M(AssertStatement)            \
-  M(LabeledStatement)           \
-  M(BreakStatement)             \
-  M(WhileStatement)             \
-  M(DoStatement)                \
-  M(ForStatement)               \
-  M(ForInStatement)             \
-  M(SwitchStatement)            \
-  M(SwitchCase)                 \
-  M(ContinueSwitchStatement)    \
-  M(IfStatement)                \
-  M(ReturnStatement)            \
-  M(TryCatch)                   \
-  M(Catch)                      \
-  M(TryFinally)                 \
-  M(YieldStatement)             \
-  M(VariableDeclaration)        \
-  M(FunctionDeclaration)        \
-  M(TypeParameter)              \
+#define KERNEL_TREE_NODES_DO(M)                                                \
+  M(Library)                                                                   \
+  M(Class)                                                                     \
+  M(NormalClass)                                                               \
+  M(MixinClass)                                                                \
+  M(Member)                                                                    \
+  M(Field)                                                                     \
+  M(Constructor)                                                               \
+  M(Procedure)                                                                 \
+  M(Initializer)                                                               \
+  M(InvalidInitializer)                                                        \
+  M(FieldInitializer)                                                          \
+  M(SuperInitializer)                                                          \
+  M(RedirectingInitializer)                                                    \
+  M(LocalInitializer)                                                          \
+  M(FunctionNode)                                                              \
+  M(Expression)                                                                \
+  M(InvalidExpression)                                                         \
+  M(VariableGet)                                                               \
+  M(VariableSet)                                                               \
+  M(PropertyGet)                                                               \
+  M(PropertySet)                                                               \
+  M(DirectPropertyGet)                                                         \
+  M(DirectPropertySet)                                                         \
+  M(StaticGet)                                                                 \
+  M(StaticSet)                                                                 \
+  M(Arguments)                                                                 \
+  M(NamedExpression)                                                           \
+  M(MethodInvocation)                                                          \
+  M(DirectMethodInvocation)                                                    \
+  M(StaticInvocation)                                                          \
+  M(ConstructorInvocation)                                                     \
+  M(Not)                                                                       \
+  M(LogicalExpression)                                                         \
+  M(ConditionalExpression)                                                     \
+  M(StringConcatenation)                                                       \
+  M(IsExpression)                                                              \
+  M(AsExpression)                                                              \
+  M(BasicLiteral)                                                              \
+  M(StringLiteral)                                                             \
+  M(BigintLiteral)                                                             \
+  M(IntLiteral)                                                                \
+  M(DoubleLiteral)                                                             \
+  M(BoolLiteral)                                                               \
+  M(NullLiteral)                                                               \
+  M(SymbolLiteral)                                                             \
+  M(TypeLiteral)                                                               \
+  M(ThisExpression)                                                            \
+  M(Rethrow)                                                                   \
+  M(Throw)                                                                     \
+  M(ListLiteral)                                                               \
+  M(MapLiteral)                                                                \
+  M(MapEntry)                                                                  \
+  M(AwaitExpression)                                                           \
+  M(FunctionExpression)                                                        \
+  M(Let)                                                                       \
+  M(BlockExpression)                                                           \
+  M(Statement)                                                                 \
+  M(InvalidStatement)                                                          \
+  M(ExpressionStatement)                                                       \
+  M(Block)                                                                     \
+  M(EmptyStatement)                                                            \
+  M(AssertStatement)                                                           \
+  M(LabeledStatement)                                                          \
+  M(BreakStatement)                                                            \
+  M(WhileStatement)                                                            \
+  M(DoStatement)                                                               \
+  M(ForStatement)                                                              \
+  M(ForInStatement)                                                            \
+  M(SwitchStatement)                                                           \
+  M(SwitchCase)                                                                \
+  M(ContinueSwitchStatement)                                                   \
+  M(IfStatement)                                                               \
+  M(ReturnStatement)                                                           \
+  M(TryCatch)                                                                  \
+  M(Catch)                                                                     \
+  M(TryFinally)                                                                \
+  M(YieldStatement)                                                            \
+  M(VariableDeclaration)                                                       \
+  M(FunctionDeclaration)                                                       \
+  M(TypeParameter)                                                             \
   M(Program)
 
-#define KERNEL_ALL_NODES_DO(M) \
-  M(Node)                      \
-  KERNEL_NODES_DO(M)           \
-  M(TreeNode)                  \
+#define KERNEL_ALL_NODES_DO(M)                                                 \
+  M(Node)                                                                      \
+  KERNEL_NODES_DO(M)                                                           \
+  M(TreeNode)                                                                  \
   KERNEL_TREE_NODES_DO(M)
 
-#define KERNEL_VISITORS_DO(M) \
-  M(ExpressionVisitor)        \
-  M(StatementVisitor)         \
-  M(MemberVisitor)            \
-  M(ClassVisitor)             \
-  M(InitializerVisitor)       \
-  M(DartTypeVisitor)          \
-  M(ClassReferenceVisitor)    \
-  M(MemberReferenceVisitor)   \
-  M(TreeVisitor)              \
+#define KERNEL_VISITORS_DO(M)                                                  \
+  M(ExpressionVisitor)                                                         \
+  M(StatementVisitor)                                                          \
+  M(MemberVisitor)                                                             \
+  M(ClassVisitor)                                                              \
+  M(InitializerVisitor)                                                        \
+  M(DartTypeVisitor)                                                           \
+  M(ClassReferenceVisitor)                                                     \
+  M(MemberReferenceVisitor)                                                    \
+  M(TreeVisitor)                                                               \
   M(Visitor)
 
 namespace dart {
 
 namespace kernel {
 
 
 class Reader;
 class TreeNode;
 class TypeParameter;
@@ skipping 197 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LineStartingTable);
 };
 
 // Forward declare all classes.
 #define DO(name) class name;
 KERNEL_ALL_NODES_DO(DO)
 KERNEL_VISITORS_DO(DO)
 #undef DO
 
 
-#define DEFINE_CASTING_OPERATIONS(klass)       \
-  virtual bool Is##klass() { return true; }    \
-                                               \
-  static klass* Cast(Node* node) {             \
-    ASSERT(node == NULL || node->Is##klass()); \
-    return static_cast<klass*>(node);          \
-  }                                            \
-                                               \
+#define DEFINE_CASTING_OPERATIONS(klass)                                       \
+  virtual bool Is##klass() { return true; }                                    \
+                                                                               \
+  static klass* Cast(Node* node) {                                             \
+    ASSERT(node == NULL || node->Is##klass());                                 \
+    return static_cast<klass*>(node);                                          \
+  }                                                                            \
+                                                                               \
   virtual Node::NodeType Type() { return Node::kType##klass; }
 
-#define DEFINE_IS_OPERATION(klass) \
+#define DEFINE_IS_OPERATION(klass)                                             \
   virtual bool Is##klass() { return false; }
 
-#define DEFINE_ALL_IS_OPERATIONS()     \
-  KERNEL_NODES_DO(DEFINE_IS_OPERATION) \
-  DEFINE_IS_OPERATION(TreeNode)        \
+#define DEFINE_ALL_IS_OPERATIONS()                                             \
+  KERNEL_NODES_DO(DEFINE_IS_OPERATION)                                         \
+  DEFINE_IS_OPERATION(TreeNode)                                                \
   KERNEL_TREE_NODES_DO(DEFINE_IS_OPERATION)
 
 
 class Node {
  public:
   virtual ~Node();
 
   enum NodeType {
 #define DO(name) kType##name,
     KERNEL_ALL_NODES_DO(DO)
 #undef DO
 
         kNumTypes
   };
 
   DEFINE_ALL_IS_OPERATIONS();
   DEFINE_CASTING_OPERATIONS(Node);
 
   virtual void AcceptVisitor(Visitor* visitor) = 0;
   virtual void VisitChildren(Visitor* visitor) = 0;
 
  protected:
-  Node() { }
+  Node() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Node);
 };
 
 
 class TreeNode : public Node {
  public:
   virtual ~TreeNode();
 
@@ skipping 196 matching lines @@
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptMemberVisitor(MemberVisitor* visitor) = 0;
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor) = 0;
 
   TreeNode* parent() { return parent_; }
   Name* name() { return name_; }
   List<Expression>& annotations() { return annotations_; }
 
  protected:
-  Member() { }
+  Member() {}
 
   template <typename T>
   friend class List;
 
   Ref<TreeNode> parent_;
   Child<Name> name_;
   List<Expression> annotations_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Member);
@@ skipping 139 matching lines @@
   virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Initializer();
 
   DEFINE_CASTING_OPERATIONS(Initializer);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor) = 0;
 
  protected:
-  Initializer() { }
+  Initializer() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Initializer);
 };
 
 
 class InvalidInitializer : public Initializer {
  public:
   static InvalidInitializer* ReadFromImpl(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
   virtual ~InvalidInitializer();
 
   DEFINE_CASTING_OPERATIONS(InvalidInitializer);
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  InvalidInitializer() { }
+  InvalidInitializer() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidInitializer);
 };
 
 
 class FieldInitializer : public Initializer {
  public:
   static FieldInitializer* ReadFromImpl(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 143 matching lines @@
   virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Expression();
 
   DEFINE_CASTING_OPERATIONS(Expression);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor) = 0;
 
  protected:
-  Expression() { }
+  Expression() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Expression);
 };
 
 
 class InvalidExpression : public Expression {
  public:
   static InvalidExpression* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
   virtual ~InvalidExpression();
   virtual void VisitChildren(Visitor* visitor);
 
   DEFINE_CASTING_OPERATIONS(InvalidExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
 
  private:
-  InvalidExpression() { }
+  InvalidExpression() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidExpression);
 };
 
 
 class VariableGet : public Expression {
  public:
   static VariableGet* ReadFrom(Reader* reader);
   static VariableGet* ReadFrom(Reader* reader, uint8_t payload);
   virtual void WriteTo(Writer* writer);
@@ skipping 305 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation);
 };
 
 
 class StaticInvocation : public Expression {
  public:
   static StaticInvocation* ReadFrom(Reader* reader, bool is_const);
   virtual void WriteTo(Writer* writer);
 
-  explicit StaticInvocation(Procedure* procedure, Arguments* args,
+  explicit StaticInvocation(Procedure* procedure,
+                            Arguments* args,
                             bool is_const)
       : procedure_(procedure), arguments_(args), is_const_(is_const) {}
   ~StaticInvocation();
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Procedure* procedure() { return procedure_; }
   Arguments* arguments() { return arguments_; }
   bool is_const() { return is_const_; }
@@ skipping 313 matching lines @@
   static NullLiteral* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
   virtual ~NullLiteral();
 
   DEFINE_CASTING_OPERATIONS(NullLiteral);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
 
  private:
-  NullLiteral() { }
+  NullLiteral() {}
 
   DISALLOW_COPY_AND_ASSIGN(NullLiteral);
 };
 
 
 class SymbolLiteral : public Expression {
  public:
   static SymbolLiteral* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 44 matching lines @@
   virtual void WriteTo(Writer* writer);
 
   virtual ~ThisExpression();
 
   DEFINE_CASTING_OPERATIONS(ThisExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  ThisExpression() { }
+  ThisExpression() {}
 
   DISALLOW_COPY_AND_ASSIGN(ThisExpression);
 };
 
 
 class Rethrow : public Expression {
  public:
   static Rethrow* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
   virtual ~Rethrow();
 
   DEFINE_CASTING_OPERATIONS(Rethrow);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  Rethrow() { }
+  Rethrow() {}
 
   DISALLOW_COPY_AND_ASSIGN(Rethrow);
 };
 
 
 class Throw : public Expression {
  public:
   static Throw* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 201 matching lines @@
   virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Statement();
 
   DEFINE_CASTING_OPERATIONS(Statement);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptStatementVisitor(StatementVisitor* visitor) = 0;
 
  protected:
-  Statement() { }
+  Statement() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Statement);
 };
 
 
 class InvalidStatement : public Statement {
  public:
   static InvalidStatement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
   virtual ~InvalidStatement();
 
   DEFINE_CASTING_OPERATIONS(InvalidStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  InvalidStatement() { }
+  InvalidStatement() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidStatement);
 };
 
 
 class ExpressionStatement : public Statement {
  public:
   static ExpressionStatement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 46 matching lines @@
   virtual void WriteTo(Writer* writer);
 
   virtual ~EmptyStatement();
 
   DEFINE_CASTING_OPERATIONS(EmptyStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  EmptyStatement() { }
+  EmptyStatement() {}
 
   DISALLOW_COPY_AND_ASSIGN(EmptyStatement);
 };
 
 
 class AssertStatement : public Statement {
  public:
   static AssertStatement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 541 matching lines @@
   bool IsAlwaysNull() { return value_bits_ == kNull; }
   bool IsAlwaysInteger() { return value_bits_ == kInteger; }
   bool IsAlwaysDouble() { return value_bits_ == kDouble; }
   bool IsAlwaysString() { return value_bits_ == kString; }
 
   Class* klass() { return klass_; }
   BaseClassKind kind() { return kind_; }
   uint8_t value_bits() { return value_bits_; }
 
  private:
-  InferredValue() { }
+  InferredValue() {}
 
   Ref<Class> klass_;
   BaseClassKind kind_;
   uint8_t value_bits_;
 
   DISALLOW_COPY_AND_ASSIGN(InferredValue);
 };
 
 
 class DartType : public Node {
  public:
   static DartType* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~DartType();
 
   DEFINE_CASTING_OPERATIONS(DartType);
 
   virtual void AcceptVisitor(Visitor* visitor);
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor) = 0;
 
  protected:
-  DartType() { }
+  DartType() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DartType);
 };
 
 
 class InvalidType : public DartType {
  public:
   static InvalidType* ReadFrom(Reader* reader);
   void WriteTo(Writer* writer);
 
   virtual ~InvalidType();
 
   DEFINE_CASTING_OPERATIONS(InvalidType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  InvalidType() { }
+  InvalidType() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidType);
 };
 
 
 class DynamicType : public DartType {
  public:
   static DynamicType* ReadFrom(Reader* reader);
   void WriteTo(Writer* writer);
 
   virtual ~DynamicType();
 
   DEFINE_CASTING_OPERATIONS(DynamicType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  DynamicType() { }
+  DynamicType() {}
 
   DISALLOW_COPY_AND_ASSIGN(DynamicType);
 };
 
 
 class VoidType : public DartType {
  public:
   static VoidType* ReadFrom(Reader* reader);
   void WriteTo(Writer* writer);
 
   virtual ~VoidType();
 
   DEFINE_CASTING_OPERATIONS(VoidType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
-  VoidType() { }
+  VoidType() {}
 
   DISALLOW_COPY_AND_ASSIGN(VoidType);
 };
 
 
 class InterfaceType : public DartType {
  public:
   static InterfaceType* ReadFrom(Reader* reader);
   static InterfaceType* ReadFrom(Reader* reader, bool _without_type_arguments_);
   void WriteTo(Writer* writer);
@@ skipping 128 matching lines @@
   Ref<Procedure> main_method_;
   StringTable string_table_;
 
   DISALLOW_COPY_AND_ASSIGN(Program);
 };
 
 
 class Reference : public AllStatic {
  public:
   static Member* ReadMemberFrom(Reader* reader, bool allow_null = false);
-  static void WriteMemberTo(Writer* writer, Member* member,
+  static void WriteMemberTo(Writer* writer,
+                            Member* member,
                             bool allow_null = false);
 
   static Class* ReadClassFrom(Reader* reader, bool allow_null = false);
-  static void WriteClassTo(Writer* writer, Class* klass,
+  static void WriteClassTo(Writer* writer,
+                           Class* klass,
                            bool allow_null = false);
 
   static String* ReadStringFrom(Reader* reader);
   static void WriteStringTo(Writer* writer, String* string);  // NOLINT
 };
 
 
 class ExpressionVisitor {
  public:
   virtual ~ExpressionVisitor() {}
@@ skipping 417 matching lines @@
   virtual void WriteBytes(uint8_t* buffer, int count) = 0;
 };
 
 
 void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program);
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_KERNEL_H_