[kernel] Stream kernel_reader

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_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "platform/assert.h"
 #include "vm/allocation.h"
@@ skipping 102 matching lines @@
   M(FunctionDeclaration)                                                       \
   M(TypeParameter)                                                             \
   M(Program)
 
 #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(DartTypeVisitor)                                                           \
-
 namespace dart {
 
 class Field;
 class ParsedFunction;
 class Zone;
 
 namespace kernel {
 
 
 class Reader;
@@ skipping 212 matching lines @@
   operator int() const { return value_; }
 
  private:
   int value_;
 };
 
 
 // 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);                                          \
   }                                                                            \
@@ skipping 595 matching lines @@
 
 
 class Expression : public TreeNode {
  public:
   static Expression* ReadFrom(Reader* reader);
 
   virtual ~Expression();
 
   DEFINE_CASTING_OPERATIONS(Expression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor) = 0;
   TokenPosition position() { return position_; }
   void set_position(TokenPosition position) { position_ = position; }
 
  protected:
   Expression() : position_(TokenPosition::kNoSource) {}
   TokenPosition position_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Expression);
 };
 
 
 class InvalidExpression : public Expression {
  public:
   static InvalidExpression* ReadFrom(Reader* reader);
 
   virtual ~InvalidExpression();
 
   DEFINE_CASTING_OPERATIONS(InvalidExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
  private:
   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 ~VariableGet();
 
   DEFINE_CASTING_OPERATIONS(VariableGet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   VariableDeclaration* variable() { return variable_; }
 
  private:
   VariableGet() {}
 
   Ref<VariableDeclaration> variable_;
   intptr_t variable_kernel_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableGet);
 };
 
 
 class VariableSet : public Expression {
  public:
   static VariableSet* ReadFrom(Reader* reader);
   static VariableSet* ReadFrom(Reader* reader, uint8_t payload);
 
   virtual ~VariableSet();
 
   DEFINE_CASTING_OPERATIONS(VariableSet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   VariableDeclaration* variable() { return variable_; }
   Expression* expression() { return expression_; }
 
  private:
   VariableSet() {}
 
   Ref<VariableDeclaration> variable_;
   intptr_t variable_kernel_offset_;
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableSet);
 };
 
 
 class PropertyGet : public Expression {
  public:
   static PropertyGet* ReadFrom(Reader* reader);
 
   virtual ~PropertyGet();
 
   DEFINE_CASTING_OPERATIONS(PropertyGet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
 
  private:
   PropertyGet() {}
 
   NameIndex interface_target_reference_;
   Child<Expression> receiver_;
   Child<Name> name_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertyGet);
 };
 
 
 class PropertySet : public Expression {
  public:
   static PropertySet* ReadFrom(Reader* reader);
 
   virtual ~PropertySet();
 
   DEFINE_CASTING_OPERATIONS(PropertySet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
   Expression* value() { return value_; }
 
  private:
   PropertySet() {}
 
   NameIndex interface_target_reference_;
   Child<Expression> receiver_;
   Child<Name> name_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertySet);
 };
 
 
 class DirectPropertyGet : public Expression {
  public:
   static DirectPropertyGet* ReadFrom(Reader* reader);
 
   virtual ~DirectPropertyGet();
 
   DEFINE_CASTING_OPERATIONS(DirectPropertyGet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* receiver() { return receiver_; }
   NameIndex target() { return target_reference_; }
 
  private:
   DirectPropertyGet() {}
 
   NameIndex target_reference_;  // Member canonical name.
   Child<Expression> receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectPropertyGet);
 };
 
 
 class DirectPropertySet : public Expression {
  public:
   static DirectPropertySet* ReadFrom(Reader* reader);
 
   virtual ~DirectPropertySet();
 
   DEFINE_CASTING_OPERATIONS(DirectPropertySet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   NameIndex target() { return target_reference_; }
   Expression* receiver() { return receiver_; }
   Expression* value() { return value_; }
 
  private:
   DirectPropertySet() {}
 
   NameIndex target_reference_;  // Member canonical name.
   Child<Expression> receiver_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectPropertySet);
 };
 
 
 class StaticGet : public Expression {
  public:
   static StaticGet* ReadFrom(Reader* reader);
 
   virtual ~StaticGet();
 
   DEFINE_CASTING_OPERATIONS(StaticGet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   NameIndex target() { return target_reference_; }
 
  private:
   StaticGet() {}
 
   NameIndex target_reference_;  // Member canonical name.
 
   DISALLOW_COPY_AND_ASSIGN(StaticGet);
 };
 
 
 class StaticSet : public Expression {
  public:
   static StaticSet* ReadFrom(Reader* reader);
 
   virtual ~StaticSet();
 
   DEFINE_CASTING_OPERATIONS(StaticSet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   NameIndex target() { return target_reference_; }
   Expression* expression() { return expression_; }
 
  private:
   StaticSet() {}
 
   NameIndex target_reference_;  // Member canonical name.
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSet);
@@ skipping 51 matching lines @@
 
 
 class MethodInvocation : public Expression {
  public:
   static MethodInvocation* ReadFrom(Reader* reader);
 
   virtual ~MethodInvocation();
 
   DEFINE_CASTING_OPERATIONS(MethodInvocation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   MethodInvocation() {}
 
   NameIndex interface_target_reference_;
   Child<Expression> receiver_;
   Child<Name> name_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(MethodInvocation);
 };
 
 
 class DirectMethodInvocation : public Expression {
  public:
   static DirectMethodInvocation* ReadFrom(Reader* reader);
 
   virtual ~DirectMethodInvocation();
 
   DEFINE_CASTING_OPERATIONS(DirectMethodInvocation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* receiver() { return receiver_; }
   NameIndex target() { return target_reference_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   DirectMethodInvocation() {}
 
   NameIndex target_reference_;  // Procedure canonical name.
   Child<Expression> receiver_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation);
 };
 
 
 class StaticInvocation : public Expression {
  public:
   static StaticInvocation* ReadFrom(Reader* reader, bool is_const);
   ~StaticInvocation();
 
   DEFINE_CASTING_OPERATIONS(StaticInvocation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   NameIndex procedure() { return procedure_reference_; }
   Arguments* arguments() { return arguments_; }
   bool is_const() { return is_const_; }
 
  private:
   StaticInvocation() {}
 
   NameIndex procedure_reference_;  // Procedure canonical name.
   bool is_const_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticInvocation);
 };
 
 
 class ConstructorInvocation : public Expression {
  public:
   static ConstructorInvocation* ReadFrom(Reader* reader, bool is_const);
 
   virtual ~ConstructorInvocation();
 
   DEFINE_CASTING_OPERATIONS(ConstructorInvocation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   bool is_const() { return is_const_; }
   NameIndex target() { return target_reference_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   ConstructorInvocation() {}
 
   bool is_const_;
   NameIndex target_reference_;  // Constructor canonical name.
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstructorInvocation);
 };
 
 
 class Not : public Expression {
  public:
   static Not* ReadFrom(Reader* reader);
 
   virtual ~Not();
 
   DEFINE_CASTING_OPERATIONS(Not);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* expression() { return expression_; }
 
  private:
   Not() {}
 
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(Not);
 };
 
 
 class LogicalExpression : public Expression {
  public:
   enum Operator { kAnd, kOr };
 
   static LogicalExpression* ReadFrom(Reader* reader);
 
   virtual ~LogicalExpression();
 
   DEFINE_CASTING_OPERATIONS(LogicalExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* left() { return left_; }
   Operator op() { return operator_; }
   Expression* right() { return right_; }
 
  private:
   LogicalExpression() {}
 
   Child<Expression> left_;
   Operator operator_;
   Child<Expression> right_;
 
   DISALLOW_COPY_AND_ASSIGN(LogicalExpression);
 };
 
 
 class ConditionalExpression : public Expression {
  public:
   static ConditionalExpression* ReadFrom(Reader* reader);
 
   virtual ~ConditionalExpression();
 
   DEFINE_CASTING_OPERATIONS(ConditionalExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* condition() { return condition_; }
   Expression* then() { return then_; }
   Expression* otherwise() { return otherwise_; }
 
  private:
   ConditionalExpression() {}
 
   Child<Expression> condition_;
   Child<Expression> then_;
   Child<Expression> otherwise_;
 
   DISALLOW_COPY_AND_ASSIGN(ConditionalExpression);
 };
 
 
 class StringConcatenation : public Expression {
  public:
   static StringConcatenation* ReadFrom(Reader* reader);
 
   virtual ~StringConcatenation();
 
   DEFINE_CASTING_OPERATIONS(StringConcatenation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   List<Expression>& expressions() { return expressions_; }
 
  private:
   StringConcatenation() {}
 
   List<Expression> expressions_;
 
   DISALLOW_COPY_AND_ASSIGN(StringConcatenation);
 };
 
 
 class IsExpression : public Expression {
  public:
   static IsExpression* ReadFrom(Reader* reader);
 
   virtual ~IsExpression();
 
   DEFINE_CASTING_OPERATIONS(IsExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* operand() { return operand_; }
   DartType* type() { return type_; }
 
  private:
   IsExpression() {}
 
   Child<Expression> operand_;
   Child<DartType> type_;
 
   DISALLOW_COPY_AND_ASSIGN(IsExpression);
 };
 
 
 class AsExpression : public Expression {
  public:
   static AsExpression* ReadFrom(Reader* reader);
 
   virtual ~AsExpression();
 
   DEFINE_CASTING_OPERATIONS(AsExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* operand() { return operand_; }
   DartType* type() { return type_; }
 
  private:
   AsExpression() {}
 
   Child<Expression> operand_;
   Child<DartType> type_;
 
   DISALLOW_COPY_AND_ASSIGN(AsExpression);
 };
 
 
 class BasicLiteral : public Expression {
  public:
   virtual ~BasicLiteral();
 
   DEFINE_CASTING_OPERATIONS(BasicLiteral);
 };
 
 
 class StringLiteral : public BasicLiteral {
  public:
   static StringLiteral* ReadFrom(Reader* reader);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   explicit StringLiteral(StringIndex string_index)
       : value_index_(string_index) {}
   virtual ~StringLiteral();
 
   DEFINE_CASTING_OPERATIONS(StringLiteral);
 
   StringIndex value() { return value_index_; }
 
  protected:
   StringLiteral() {}
 
   StringIndex value_index_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StringLiteral);
 };
 
 
 class BigintLiteral : public StringLiteral {
  public:
   static BigintLiteral* ReadFrom(Reader* reader);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   explicit BigintLiteral(StringIndex string_index)
       : StringLiteral(string_index) {}
   virtual ~BigintLiteral();
 
   DEFINE_CASTING_OPERATIONS(BigintLiteral);
 
  private:
   BigintLiteral() {}
 
   DISALLOW_COPY_AND_ASSIGN(BigintLiteral);
 };
 
 
 class IntLiteral : public BasicLiteral {
  public:
   static IntLiteral* ReadFrom(Reader* reader, bool is_negative);
   static IntLiteral* ReadFrom(Reader* reader, uint8_t payload);
 
   virtual ~IntLiteral();
 
   DEFINE_CASTING_OPERATIONS(IntLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   int64_t value() { return value_; }
 
  private:
   IntLiteral() {}
 
   int64_t value_;
 
   DISALLOW_COPY_AND_ASSIGN(IntLiteral);
 };
 
 
 class DoubleLiteral : public BasicLiteral {
  public:
   static DoubleLiteral* ReadFrom(Reader* reader);
 
   virtual ~DoubleLiteral();
 
   DEFINE_CASTING_OPERATIONS(DoubleLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   StringIndex value() { return value_index_; }
 
  private:
   DoubleLiteral() {}
 
   StringIndex value_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleLiteral);
 };
 
 
 class BoolLiteral : public BasicLiteral {
  public:
   static BoolLiteral* ReadFrom(Reader* reader, bool value);
 
   virtual ~BoolLiteral();
 
   DEFINE_CASTING_OPERATIONS(BoolLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   bool value() { return value_; }
 
  private:
   BoolLiteral() {}
 
   bool value_;
 
   DISALLOW_COPY_AND_ASSIGN(BoolLiteral);
 };
 
 
 class NullLiteral : public BasicLiteral {
  public:
   static NullLiteral* ReadFrom(Reader* reader);
 
   virtual ~NullLiteral();
 
   DEFINE_CASTING_OPERATIONS(NullLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
  private:
   NullLiteral() {}
 
   DISALLOW_COPY_AND_ASSIGN(NullLiteral);
 };
 
 
 class SymbolLiteral : public Expression {
  public:
   static SymbolLiteral* ReadFrom(Reader* reader);
 
   virtual ~SymbolLiteral();
 
   DEFINE_CASTING_OPERATIONS(SymbolLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   StringIndex value() { return value_index_; }
 
  private:
   SymbolLiteral() {}
 
   StringIndex value_index_;
 
   DISALLOW_COPY_AND_ASSIGN(SymbolLiteral);
 };
 
 
 class TypeLiteral : public Expression {
  public:
   static TypeLiteral* ReadFrom(Reader* reader);
 
   virtual ~TypeLiteral();
 
   DEFINE_CASTING_OPERATIONS(TypeLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   DartType* type() { return type_; }
 
  private:
   TypeLiteral() {}
 
   Child<DartType> type_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeLiteral);
 };
 
 
 class ThisExpression : public Expression {
  public:
   static ThisExpression* ReadFrom(Reader* reader);
 
   virtual ~ThisExpression();
 
   DEFINE_CASTING_OPERATIONS(ThisExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
  private:
   ThisExpression() {}
 
   DISALLOW_COPY_AND_ASSIGN(ThisExpression);
 };
 
 
 class Rethrow : public Expression {
  public:
   static Rethrow* ReadFrom(Reader* reader);
 
   virtual ~Rethrow();
 
   DEFINE_CASTING_OPERATIONS(Rethrow);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
  private:
   Rethrow() {}
 
   DISALLOW_COPY_AND_ASSIGN(Rethrow);
 };
 
 
 class Throw : public Expression {
  public:
   static Throw* ReadFrom(Reader* reader);
 
   virtual ~Throw();
 
   DEFINE_CASTING_OPERATIONS(Throw);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* expression() { return expression_; }
 
  private:
   Throw() {}
 
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(Throw);
 };
 
 
 class ListLiteral : public Expression {
  public:
   static ListLiteral* ReadFrom(Reader* reader, bool is_const);
 
   virtual ~ListLiteral();
 
   DEFINE_CASTING_OPERATIONS(ListLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   bool is_const() { return is_const_; }
   DartType* type() { return type_; }
   List<Expression>& expressions() { return expressions_; }
 
  private:
   ListLiteral() {}
 
   bool is_const_;
   Child<DartType> type_;
   List<Expression> expressions_;
 
   DISALLOW_COPY_AND_ASSIGN(ListLiteral);
 };
 
 
 class MapLiteral : public Expression {
  public:
   static MapLiteral* ReadFrom(Reader* reader, bool is_const);
 
   virtual ~MapLiteral();
 
   DEFINE_CASTING_OPERATIONS(MapLiteral);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   bool is_const() { return is_const_; }
   DartType* key_type() { return key_type_; }
   DartType* value_type() { return value_type_; }
   List<MapEntry>& entries() { return entries_; }
 
  private:
   MapLiteral() {}
 
   bool is_const_;
   Child<DartType> key_type_;
@@ skipping 29 matching lines @@
 
 
 class AwaitExpression : public Expression {
  public:
   static AwaitExpression* ReadFrom(Reader* reader);
 
   virtual ~AwaitExpression();
 
   DEFINE_CASTING_OPERATIONS(AwaitExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* operand() { return operand_; }
 
  private:
   AwaitExpression() {}
 
   Child<Expression> operand_;
 
   DISALLOW_COPY_AND_ASSIGN(AwaitExpression);
 };
 
 
 class FunctionExpression : public Expression {
  public:
   static FunctionExpression* ReadFrom(Reader* reader);
 
   virtual ~FunctionExpression();
 
   DEFINE_CASTING_OPERATIONS(FunctionExpression);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   FunctionNode* function() { return function_; }
 
  private:
   FunctionExpression() {}
 
   Child<FunctionNode> function_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionExpression);
 };
 
 
 class Let : public Expression {
  public:
   static Let* ReadFrom(Reader* reader);
 
   virtual ~Let();
 
   DEFINE_CASTING_OPERATIONS(Let);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   VariableDeclaration* variable() { return variable_; }
   Expression* body() { return body_; }
   TokenPosition position() { return position_; }
   TokenPosition end_position() { return end_position_; }
 
  private:
   Let()
       : position_(TokenPosition::kNoSource),
         end_position_(TokenPosition::kNoSource) {}
 
   Child<VariableDeclaration> variable_;
   Child<Expression> body_;
   TokenPosition position_;
   TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(Let);
 };
 
 
 class VectorCreation : public Expression {
  public:
   static VectorCreation* ReadFrom(Reader* reader);
 
   virtual ~VectorCreation();
 
   DEFINE_CASTING_OPERATIONS(VectorCreation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   intptr_t value() { return value_; }
 
  private:
   VectorCreation() {}
 
   intptr_t value_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorCreation);
 };
 
 
 class VectorGet : public Expression {
  public:
   static VectorGet* ReadFrom(Reader* reader);
 
   virtual ~VectorGet();
 
   DEFINE_CASTING_OPERATIONS(VectorGet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* vector_expression() { return vector_expression_; }
   intptr_t index() { return index_; }
 
  private:
   VectorGet() {}
 
   Child<Expression> vector_expression_;
   intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorGet);
 };
 
 
 class VectorSet : public Expression {
  public:
   static VectorSet* ReadFrom(Reader* reader);
 
   virtual ~VectorSet();
 
   DEFINE_CASTING_OPERATIONS(VectorSet);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* vector_expression() { return vector_expression_; }
   intptr_t index() { return index_; }
   Expression* value() { return value_; }
 
  private:
   VectorSet() {}
 
   Child<Expression> vector_expression_;
   intptr_t index_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorSet);
 };
 
 
 class VectorCopy : public Expression {
  public:
   static VectorCopy* ReadFrom(Reader* reader);
 
   virtual ~VectorCopy();
 
   DEFINE_CASTING_OPERATIONS(VectorCopy);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   Expression* vector_expression() { return vector_expression_; }
 
  private:
   VectorCopy() {}
 
   Child<Expression> vector_expression_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorCopy);
 };
 
 
 class ClosureCreation : public Expression {
  public:
   static ClosureCreation* ReadFrom(Reader* reader);
 
   virtual ~ClosureCreation();
 
   DEFINE_CASTING_OPERATIONS(ClosureCreation);
 
-  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
-
   NameIndex top_level_function() { return top_level_function_reference_; }
   Expression* context_vector() { return context_vector_; }
   FunctionType* function_type() { return function_type_; }
 
  private:
   ClosureCreation() {}
 
   NameIndex top_level_function_reference_;  // Procedure canonical name.
   Child<Expression> context_vector_;
   Child<FunctionType> function_type_;
@@ skipping 559 matching lines @@
 
 
 class DartType : public Node {
  public:
   static DartType* ReadFrom(Reader* reader);
 
   virtual ~DartType();
 
   DEFINE_CASTING_OPERATIONS(DartType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor) = 0;
-
  protected:
   DartType() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DartType);
 };
 
 
 class InvalidType : public DartType {
  public:
   static InvalidType* ReadFrom(Reader* reader);
 
   virtual ~InvalidType();
 
   DEFINE_CASTING_OPERATIONS(InvalidType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
  private:
   InvalidType() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidType);
 };
 
 
 class DynamicType : public DartType {
  public:
   static DynamicType* ReadFrom(Reader* reader);
 
   virtual ~DynamicType();
 
   DEFINE_CASTING_OPERATIONS(DynamicType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
  private:
   DynamicType() {}
 
   DISALLOW_COPY_AND_ASSIGN(DynamicType);
 };
 
 
 class VoidType : public DartType {
  public:
   static VoidType* ReadFrom(Reader* reader);
 
   virtual ~VoidType();
 
   DEFINE_CASTING_OPERATIONS(VoidType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
  private:
   VoidType() {}
 
   DISALLOW_COPY_AND_ASSIGN(VoidType);
 };
 
 
 class BottomType : public DartType {
  public:
   static BottomType* ReadFrom(Reader* reader);
 
   virtual ~BottomType();
 
   DEFINE_CASTING_OPERATIONS(BottomType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
  private:
   BottomType() {}
 
   DISALLOW_COPY_AND_ASSIGN(BottomType);
 };
 
 
 class InterfaceType : public DartType {
  public:
   static InterfaceType* ReadFrom(Reader* reader);
   static InterfaceType* ReadFrom(Reader* reader, bool _without_type_arguments_);
 
   explicit InterfaceType(NameIndex class_reference)
       : class_reference_(class_reference) {}
   virtual ~InterfaceType();
 
   DEFINE_CASTING_OPERATIONS(InterfaceType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
   NameIndex klass() { return class_reference_; }
   List<DartType>& type_arguments() { return type_arguments_; }
 
  private:
   InterfaceType() {}
 
   NameIndex class_reference_;  // Class canonical name.
   List<DartType> type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceType);
 };
 
 
 class TypedefType : public DartType {
  public:
   static TypedefType* ReadFrom(Reader* reader);
 
   explicit TypedefType(NameIndex class_reference)
       : typedef_reference_(class_reference) {}
   virtual ~TypedefType();
 
   DEFINE_CASTING_OPERATIONS(TypedefType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
   NameIndex typedef_reference() { return typedef_reference_; }
   List<DartType>& type_arguments() { return type_arguments_; }
 
  private:
   TypedefType() {}
 
   NameIndex typedef_reference_;  // Typedef canonical name.
   List<DartType> type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(TypedefType);
@@ skipping 22 matching lines @@
 
 class FunctionType : public DartType {
  public:
   static FunctionType* ReadFrom(Reader* reader);
   static FunctionType* ReadFrom(Reader* reader, bool _without_type_arguments_);
 
   virtual ~FunctionType();
 
   DEFINE_CASTING_OPERATIONS(FunctionType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
   TypeParameterList& type_parameters() { return type_parameters_; }
   int required_parameter_count() { return required_parameter_count_; }
   List<DartType>& positional_parameters() { return positional_parameters_; }
   List<NamedParameter>& named_parameters() { return named_parameters_; }
   DartType* return_type() { return return_type_; }
 
  private:
   FunctionType() {}
 
   TypeParameterList type_parameters_;
   int required_parameter_count_;
   List<DartType> positional_parameters_;
   List<NamedParameter> named_parameters_;
   Child<DartType> return_type_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionType);
 };
 
 
 class TypeParameterType : public DartType {
  public:
   static TypeParameterType* ReadFrom(Reader* reader);
 
   virtual ~TypeParameterType();
 
   DEFINE_CASTING_OPERATIONS(TypeParameterType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
   TypeParameter* parameter() { return parameter_; }
 
  private:
   TypeParameterType() {}
 
   Ref<TypeParameter> parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeParameterType);
 };
 
 
 class VectorType : public DartType {
  public:
   static VectorType* ReadFrom(Reader* reader);
 
   virtual ~VectorType();
 
   DEFINE_CASTING_OPERATIONS(VectorType);
 
-  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
-
  private:
   VectorType() {}
 
   DISALLOW_COPY_AND_ASSIGN(VectorType);
 };
 
 
 class TypeParameter : public TreeNode {
  public:
   TypeParameter* ReadFrom(Reader* reader);
@@ skipping 55 matching lines @@
 class Reference : public AllStatic {
  public:
   // Read canonical name references.
   static NameIndex ReadMemberFrom(Reader* reader, bool allow_null = false);
   static NameIndex ReadClassFrom(Reader* reader, bool allow_null = false);
   static NameIndex ReadTypedefFrom(Reader* reader);
   static NameIndex ReadLibraryFrom(Reader* reader);
 };
 
 
-class ExpressionVisitor {
- public:
-  virtual ~ExpressionVisitor() {}
-
-  virtual void VisitDefaultExpression(Expression* node) = 0;
-  virtual void VisitDefaultBasicLiteral(BasicLiteral* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitInvalidExpression(InvalidExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitVariableGet(VariableGet* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitVariableSet(VariableSet* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitPropertyGet(PropertyGet* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitPropertySet(PropertySet* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitDirectPropertyGet(DirectPropertyGet* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitDirectPropertySet(DirectPropertySet* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitStaticGet(StaticGet* node) { VisitDefaultExpression(node); }
-  virtual void VisitStaticSet(StaticSet* node) { VisitDefaultExpression(node); }
-  virtual void VisitMethodInvocation(MethodInvocation* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitDirectMethodInvocation(DirectMethodInvocation* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitStaticInvocation(StaticInvocation* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitConstructorInvocation(ConstructorInvocation* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitNot(Not* node) { VisitDefaultExpression(node); }
-  virtual void VisitLogicalExpression(LogicalExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitConditionalExpression(ConditionalExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitStringConcatenation(StringConcatenation* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitIsExpression(IsExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitAsExpression(AsExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitSymbolLiteral(SymbolLiteral* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitTypeLiteral(TypeLiteral* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitThisExpression(ThisExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitRethrow(Rethrow* node) { VisitDefaultExpression(node); }
-  virtual void VisitThrow(Throw* node) { VisitDefaultExpression(node); }
-  virtual void VisitListLiteral(ListLiteral* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitMapLiteral(MapLiteral* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitAwaitExpression(AwaitExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitFunctionExpression(FunctionExpression* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitStringLiteral(StringLiteral* node) {
-    VisitDefaultBasicLiteral(node);
-  }
-  virtual void VisitBigintLiteral(BigintLiteral* node) {
-    VisitDefaultBasicLiteral(node);
-  }
-  virtual void VisitIntLiteral(IntLiteral* node) {
-    VisitDefaultBasicLiteral(node);
-  }
-  virtual void VisitDoubleLiteral(DoubleLiteral* node) {
-    VisitDefaultBasicLiteral(node);
-  }
-  virtual void VisitBoolLiteral(BoolLiteral* node) {
-    VisitDefaultBasicLiteral(node);
-  }
-  virtual void VisitNullLiteral(NullLiteral* node) {
-    VisitDefaultBasicLiteral(node);
-  }
-  virtual void VisitLet(Let* node) { VisitDefaultExpression(node); }
-  virtual void VisitVectorCreation(VectorCreation* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitVectorGet(VectorGet* node) { VisitDefaultExpression(node); }
-  virtual void VisitVectorSet(VectorSet* node) { VisitDefaultExpression(node); }
-  virtual void VisitVectorCopy(VectorCopy* node) {
-    VisitDefaultExpression(node);
-  }
-  virtual void VisitClosureCreation(ClosureCreation* node) {
-    VisitDefaultExpression(node);
-  }
-};
-
-
-class DartTypeVisitor {
- public:
-  virtual ~DartTypeVisitor() {}
-
-  virtual void VisitDefaultDartType(DartType* node) = 0;
-  virtual void VisitInvalidType(InvalidType* node) {
-    VisitDefaultDartType(node);
-  }
-  virtual void VisitDynamicType(DynamicType* node) {
-    VisitDefaultDartType(node);
-  }
-  virtual void VisitVoidType(VoidType* node) { VisitDefaultDartType(node); }
-  virtual void VisitBottomType(BottomType* node) { VisitDefaultDartType(node); }
-  virtual void VisitInterfaceType(InterfaceType* node) {
-    VisitDefaultDartType(node);
-  }
-  virtual void VisitFunctionType(FunctionType* node) {
-    VisitDefaultDartType(node);
-  }
-  virtual void VisitTypeParameterType(TypeParameterType* node) {
-    VisitDefaultDartType(node);
-  }
-  virtual void VisitVectorType(VectorType* node) { VisitDefaultDartType(node); }
-  virtual void VisitTypedefType(TypedefType* node) {
-    VisitDefaultDartType(node);
-  }
-};
-
-
 template <typename T>
 List<T>::~List() {
   for (int i = 0; i < length_; i++) {
     delete array_[i];
   }
   delete[] array_;
 }
 
 
 template <typename T>
@@ skipping 59 matching lines @@
 }  // namespace kernel
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length);
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_