Remove (semi-unmaintained) kernel write code

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 117 matching lines @@
 class Field;
 class ParsedFunction;
 class Zone;
 
 namespace kernel {
 
 
 class Reader;
 class TreeNode;
 class TypeParameter;
-class Writer;
 
 // Boxes a value of type `T*` and `delete`s it on destruction.
 template <typename T>
 class Child {
  public:
   Child() : pointer_(NULL) {}
   explicit Child(T* value) : pointer_(value) {}
 
   ~Child() { delete pointer_; }
 
@@ skipping 43 matching lines @@
 
   template <typename IT>
   void ReadFrom(Reader* reader);
 
   template <typename IT>
   void ReadFrom(Reader* reader, TreeNode* parent);
 
   template <typename IT>
   void ReadFromStatic(Reader* reader);
 
-  void WriteTo(Writer* writer);
-
-  template <typename IT>
-  void WriteToStatic(Writer* writer);
-
   // Extends the array to at least be able to hold [length] elements.
   //
   // Free places will be filled with `NULL` values.
   void EnsureInitialized(int length);
 
   // Returns element at [index].
   //
   // If the array is not big enough, it will be grown via `EnsureInitialized`.
   // If the element doesn't exist, it will be created via `new IT()`.
   template <typename IT>
@@ skipping 16 matching lines @@
   T** array_;
   int length_;
 
   DISALLOW_COPY_AND_ASSIGN(List);
 };
 
 
 class TypeParameterList : public List<TypeParameter> {
  public:
   void ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 };
 
 
 template <typename A, typename B>
 class Tuple {
  public:
   static Tuple<A, B>* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   Tuple(A* a, B* b) : first_(a), second_(b) {}
 
   A* first() { return first_; }
   B* second() { return second_; }
 
  private:
   Tuple() {}
 
   Ref<A> first_;
   Child<B> second_;
 
   DISALLOW_COPY_AND_ASSIGN(Tuple);
 };
 
 
 class String {
  public:
   static String* ReadFrom(Reader* reader);
   static String* ReadFromImpl(Reader* reader);
-  void WriteTo(Writer* writer);
-  void WriteToImpl(Writer* writer);
 
   String(const uint8_t* utf8, int length) {
     buffer_ = new uint8_t[length];
     size_ = length;
     memmove(buffer_, utf8, length);
   }
   ~String() { delete[] buffer_; }
 
   uint8_t* buffer() { return buffer_; }
   int size() { return size_; }
 
   bool is_empty() { return size_ == 0; }
 
  private:
   uint8_t* buffer_;
   int size_;
 
   DISALLOW_COPY_AND_ASSIGN(String);
 };
 
 
 class StringTable {
  public:
   void ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   List<String>& strings() { return strings_; }
 
  private:
   StringTable() {}
 
   friend class Program;
 
   List<String> strings_;
 
   DISALLOW_COPY_AND_ASSIGN(StringTable);
 };
 
 
 class SourceTable {
  public:
   void ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
   ~SourceTable() {
     for (intptr_t i = 0; i < size_; ++i) {
       delete source_code_[i];
       delete[] line_starts_[i];
     }
     delete[] source_code_;
     delete[] line_starts_;
     delete[] line_count_;
   }
 
@@ skipping 81 matching lines @@
   TreeNode() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TreeNode);
 };
 
 
 class Library : public TreeNode {
  public:
   Library* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Library();
 
   DEFINE_CASTING_OPERATIONS(Library);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* import_uri() { return import_uri_; }
   intptr_t source_uri_index() { return source_uri_index_; }
@@ skipping 37 matching lines @@
   List<Field> fields_;
   List<Procedure> procedures_;
 
   DISALLOW_COPY_AND_ASSIGN(Library);
 };
 
 
 class Class : public TreeNode {
  public:
   Class* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Class();
 
   DEFINE_CASTING_OPERATIONS(Class);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptClassVisitor(ClassVisitor* visitor) = 0;
   virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor) = 0;
 
   Library* parent() { return parent_; }
@@ skipping 23 matching lines @@
   List<Expression> annotations_;
   TokenPosition position_;
 
   DISALLOW_COPY_AND_ASSIGN(Class);
 };
 
 
 class NormalClass : public Class {
  public:
   NormalClass* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~NormalClass();
 
   DEFINE_CASTING_OPERATIONS(NormalClass);
 
   virtual void AcceptClassVisitor(ClassVisitor* visitor);
   virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   virtual TypeParameterList& type_parameters() { return type_parameters_; }
@@ skipping 18 matching lines @@
   List<Procedure> procedures_;
   List<Field> fields_;
 
   DISALLOW_COPY_AND_ASSIGN(NormalClass);
 };
 
 
 class MixinClass : public Class {
  public:
   MixinClass* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~MixinClass();
 
   DEFINE_CASTING_OPERATIONS(MixinClass);
 
   virtual void AcceptClassVisitor(ClassVisitor* visitor);
   virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   virtual TypeParameterList& type_parameters() { return type_parameters_; }
@@ skipping 63 matching lines @@
 
 class Field : public Member {
  public:
   enum Flags {
     kFlagFinal = 1 << 0,
     kFlagConst = 1 << 1,
     kFlagStatic = 1 << 2,
   };
 
   Field* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Field();
 
   DEFINE_CASTING_OPERATIONS(Field);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
@@ skipping 22 matching lines @@
 
 
 class Constructor : public Member {
  public:
   enum Flags {
     kFlagConst = 1 << 0,
     kFlagExternal = 1 << 1,
   };
 
   Constructor* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Constructor();
 
   DEFINE_CASTING_OPERATIONS(Constructor);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; }
@@ skipping 30 matching lines @@
     kMethod,
     kGetter,
     kSetter,
     kOperator,
     kFactory,
 
     kIncompleteProcedure = 255
   };
 
   Procedure* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Procedure();
 
   DEFINE_CASTING_OPERATIONS(Procedure);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   ProcedureKind kind() { return kind_; }
@@ skipping 16 matching lines @@
   intptr_t source_uri_index_;
   Child<FunctionNode> function_;
 
   DISALLOW_COPY_AND_ASSIGN(Procedure);
 };
 
 
 class Initializer : public TreeNode {
  public:
   static Initializer* ReadFrom(Reader* reader);
-  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() {}
 
  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() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidInitializer);
 };
 
 
 class FieldInitializer : public Initializer {
  public:
   static FieldInitializer* ReadFromImpl(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~FieldInitializer();
 
   DEFINE_CASTING_OPERATIONS(FieldInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Field* field() { return field_; }
   Expression* value() { return value_; }
 
  private:
   FieldInitializer() {}
 
   Ref<Field> field_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(FieldInitializer);
 };
 
 
 class SuperInitializer : public Initializer {
  public:
   static SuperInitializer* ReadFromImpl(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~SuperInitializer();
 
   DEFINE_CASTING_OPERATIONS(SuperInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Constructor* target() { return target_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   SuperInitializer() {}
 
   Ref<Constructor> target_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(SuperInitializer);
 };
 
 
 class RedirectingInitializer : public Initializer {
  public:
   static RedirectingInitializer* ReadFromImpl(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~RedirectingInitializer();
 
   DEFINE_CASTING_OPERATIONS(RedirectingInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Constructor* target() { return target_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   RedirectingInitializer() {}
 
   Ref<Constructor> target_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(RedirectingInitializer);
 };
 
 
 class LocalInitializer : public Initializer {
  public:
   static LocalInitializer* ReadFromImpl(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~LocalInitializer();
 
   DEFINE_CASTING_OPERATIONS(LocalInitializer);
 
   virtual void AcceptInitializerVisitor(InitializerVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
 
@@ skipping 10 matching lines @@
  public:
   enum AsyncMarker {
     kSync = 0,
     kSyncStar = 1,
     kAsync = 2,
     kAsyncStar = 3,
     kSyncYielding = 4,
   };
 
   static FunctionNode* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~FunctionNode();
 
   DEFINE_CASTING_OPERATIONS(FunctionNode);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   AsyncMarker async_marker() { return async_marker_; }
   bool debuggable() { return debuggable_; }
@@ skipping 26 matching lines @@
   TokenPosition position_;
   TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionNode);
 };
 
 
 class Expression : public TreeNode {
  public:
   static Expression* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Expression();
 
   DEFINE_CASTING_OPERATIONS(Expression);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor) = 0;
   TokenPosition position() { return 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 void WriteTo(Writer* writer);
 
   virtual ~InvalidExpression();
   virtual void VisitChildren(Visitor* visitor);
 
   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 void WriteTo(Writer* writer);
 
   virtual ~VariableGet();
 
   DEFINE_CASTING_OPERATIONS(VariableGet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
 
  private:
   VariableGet() {}
 
   Ref<VariableDeclaration> variable_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableGet);
 };
 
 
 class VariableSet : public Expression {
  public:
   static VariableSet* ReadFrom(Reader* reader);
   static VariableSet* ReadFrom(Reader* reader, uint8_t payload);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~VariableSet();
 
   DEFINE_CASTING_OPERATIONS(VariableSet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   Expression* expression() { return expression_; }
 
  private:
   VariableSet() {}
 
   Ref<VariableDeclaration> variable_;
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableSet);
 };
 
 
 class PropertyGet : public Expression {
  public:
   static PropertyGet* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~PropertyGet();
 
   DEFINE_CASTING_OPERATIONS(PropertyGet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
 
  private:
   PropertyGet() {}
 
   Child<Expression> receiver_;
   Child<Name> name_;
   Ref<Member> interfaceTarget_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertyGet);
 };
 
 
 class PropertySet : public Expression {
  public:
   static PropertySet* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~PropertySet();
 
   DEFINE_CASTING_OPERATIONS(PropertySet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
   Expression* value() { return value_; }
 
  private:
   PropertySet() {}
 
   Child<Expression> receiver_;
   Child<Name> name_;
   Child<Expression> value_;
   Ref<Member> interfaceTarget_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertySet);
 };
 
 
 class DirectPropertyGet : public Expression {
  public:
   static DirectPropertyGet* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~DirectPropertyGet();
 
   DEFINE_CASTING_OPERATIONS(DirectPropertyGet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Member* target() { return target_; }
 
  private:
   DirectPropertyGet() {}
 
   Child<Expression> receiver_;
   Ref<Member> target_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectPropertyGet);
 };
 
 
 class DirectPropertySet : public Expression {
  public:
   static DirectPropertySet* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~DirectPropertySet();
 
   DEFINE_CASTING_OPERATIONS(DirectPropertySet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Member* target() { return target_; }
   Expression* value() { return value_; }
 
  private:
   DirectPropertySet() {}
 
   Child<Expression> receiver_;
   Ref<Member> target_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectPropertySet);
 };
 
 
 class StaticGet : public Expression {
  public:
   static StaticGet* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~StaticGet();
 
   DEFINE_CASTING_OPERATIONS(StaticGet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Member* target() { return target_; }
 
  private:
   StaticGet() {}
 
   Ref<Member> target_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticGet);
 };
 
 
 class StaticSet : public Expression {
  public:
   static StaticSet* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~StaticSet();
 
   DEFINE_CASTING_OPERATIONS(StaticSet);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Member* target() { return target_; }
   Expression* expression() { return expression_; }
 
  private:
   StaticSet() {}
 
   Ref<Member> target_;
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSet);
 };
 
 
 class Arguments : public TreeNode {
  public:
   static Arguments* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~Arguments();
 
   DEFINE_CASTING_OPERATIONS(Arguments);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   List<DartType>& types() { return types_; }
   List<Expression>& positional() { return positional_; }
   List<NamedExpression>& named() { return named_; }
 
   int count() { return positional_.length() + named_.length(); }
 
  private:
   Arguments() {}
 
   List<DartType> types_;
   List<Expression> positional_;
   List<NamedExpression> named_;
 
   DISALLOW_COPY_AND_ASSIGN(Arguments);
 };
 
 
 class NamedExpression : public TreeNode {
  public:
   static NamedExpression* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   NamedExpression(String* name, Expression* expr)
       : name_(name), expression_(expr) {}
   virtual ~NamedExpression();
 
   DEFINE_CASTING_OPERATIONS(NamedExpression);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* name() { return name_; }
   Expression* expression() { return expression_; }
 
  private:
   NamedExpression() {}
 
   Ref<String> name_;
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(NamedExpression);
 };
 
 
 class MethodInvocation : public Expression {
  public:
   static MethodInvocation* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~MethodInvocation();
 
   DEFINE_CASTING_OPERATIONS(MethodInvocation);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Name* name() { return name_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   MethodInvocation() {}
 
   Child<Expression> receiver_;
   Child<Name> name_;
   Child<Arguments> arguments_;
   Ref<Member> interfaceTarget_;
 
   DISALLOW_COPY_AND_ASSIGN(MethodInvocation);
 };
 
 
 class DirectMethodInvocation : public Expression {
  public:
   static DirectMethodInvocation* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~DirectMethodInvocation();
 
   DEFINE_CASTING_OPERATIONS(DirectMethodInvocation);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* receiver() { return receiver_; }
   Procedure* target() { return target_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   DirectMethodInvocation() {}
 
   Child<Expression> receiver_;
   Ref<Procedure> target_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation);
 };
 
 
 class StaticInvocation : public Expression {
  public:
   static StaticInvocation* ReadFrom(Reader* reader, bool is_const);
-  virtual void WriteTo(Writer* writer);
   ~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_; }
 
  private:
   StaticInvocation() {}
 
   Ref<Procedure> procedure_;
   Child<Arguments> arguments_;
   bool is_const_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticInvocation);
 };
 
 
 class ConstructorInvocation : public Expression {
  public:
   static ConstructorInvocation* ReadFrom(Reader* reader, bool is_const);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~ConstructorInvocation();
 
   DEFINE_CASTING_OPERATIONS(ConstructorInvocation);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool is_const() { return is_const_; }
   Constructor* target() { return target_; }
   Arguments* arguments() { return arguments_; }
 
  private:
   ConstructorInvocation() {}
 
   bool is_const_;
   Ref<Constructor> target_;
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstructorInvocation);
 };
 
 
 class Not : public Expression {
  public:
   static Not* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~Not();
 
   DEFINE_CASTING_OPERATIONS(Not);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~LogicalExpression();
 
   DEFINE_CASTING_OPERATIONS(LogicalExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~ConditionalExpression();
 
   DEFINE_CASTING_OPERATIONS(ConditionalExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~StringConcatenation();
 
   DEFINE_CASTING_OPERATIONS(StringConcatenation);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~IsExpression();
 
   DEFINE_CASTING_OPERATIONS(IsExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~AsExpression();
 
   DEFINE_CASTING_OPERATIONS(AsExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* operand() { return operand_; }
   DartType* type() { return type_; }
@@ skipping 14 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(BasicLiteral);
 
   virtual void VisitChildren(Visitor* visitor);
 };
 
 
 class StringLiteral : public BasicLiteral {
  public:
   static StringLiteral* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
 
   explicit StringLiteral(String* string) : value_(string) {}
   virtual ~StringLiteral();
 
   DEFINE_CASTING_OPERATIONS(StringLiteral);
 
   String* value() { return value_; }
 
  protected:
   StringLiteral() {}
 
   Ref<String> value_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StringLiteral);
 };
 
 
 class BigintLiteral : public StringLiteral {
  public:
   static BigintLiteral* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
 
   explicit BigintLiteral(String* string) : StringLiteral(string) {}
   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 void WriteTo(Writer* writer);
 
   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 void WriteTo(Writer* writer);
 
   virtual ~DoubleLiteral();
 
   DEFINE_CASTING_OPERATIONS(DoubleLiteral);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
 
   String* value() { return value_; }
 
  private:
   DoubleLiteral() {}
 
   Ref<String> value_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleLiteral);
 };
 
 
 class BoolLiteral : public BasicLiteral {
  public:
   static BoolLiteral* ReadFrom(Reader* reader, bool value);
-  virtual void WriteTo(Writer* writer);
 
   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 void WriteTo(Writer* writer);
 
   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 void WriteTo(Writer* writer);
 
   virtual ~SymbolLiteral();
 
   DEFINE_CASTING_OPERATIONS(SymbolLiteral);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* value() { return value_; }
 
  private:
   SymbolLiteral() {}
 
   Ref<String> value_;
 
   DISALLOW_COPY_AND_ASSIGN(SymbolLiteral);
 };
 
 
 class TypeLiteral : public Expression {
  public:
   static TypeLiteral* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~TypeLiteral();
 
   DEFINE_CASTING_OPERATIONS(TypeLiteral);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~ThisExpression();
 
   DEFINE_CASTING_OPERATIONS(ThisExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
   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() {}
 
   DISALLOW_COPY_AND_ASSIGN(Rethrow);
 };
 
 
 class Throw : public Expression {
  public:
   static Throw* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~Throw();
 
   DEFINE_CASTING_OPERATIONS(Throw);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~ListLiteral();
 
   DEFINE_CASTING_OPERATIONS(ListLiteral);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~MapLiteral();
 
   DEFINE_CASTING_OPERATIONS(MapLiteral);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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_;
   Child<DartType> value_type_;
   List<MapEntry> entries_;
 
   DISALLOW_COPY_AND_ASSIGN(MapLiteral);
 };
 
 
 class MapEntry : public TreeNode {
  public:
   static MapEntry* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~MapEntry();
 
   DEFINE_CASTING_OPERATIONS(MapEntry);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* key() { return key_; }
   Expression* value() { return value_; }
 
  private:
   MapEntry() {}
 
   template <typename T>
   friend class List;
 
   Child<Expression> key_;
   Child<Expression> value_;
 
   DISALLOW_COPY_AND_ASSIGN(MapEntry);
 };
 
 
 class AwaitExpression : public Expression {
  public:
   static AwaitExpression* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~AwaitExpression();
 
   DEFINE_CASTING_OPERATIONS(AwaitExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~FunctionExpression();
 
   DEFINE_CASTING_OPERATIONS(FunctionExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* 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 void WriteTo(Writer* writer);
 
   virtual ~Let();
 
   DEFINE_CASTING_OPERATIONS(Let);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   Expression* body() { return body_; }
@@ skipping 10 matching lines @@
   TokenPosition position_;
   TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(Let);
 };
 
 
 class Statement : public TreeNode {
  public:
   static Statement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Statement();
 
   DEFINE_CASTING_OPERATIONS(Statement);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptStatementVisitor(StatementVisitor* visitor) = 0;
   TokenPosition position() { return position_; }
 
  protected:
   Statement() : position_(TokenPosition::kNoSource) {}
   TokenPosition position_;
 
  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() {}
 
   DISALLOW_COPY_AND_ASSIGN(InvalidStatement);
 };
 
 
 class ExpressionStatement : public Statement {
  public:
   static ExpressionStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   explicit ExpressionStatement(Expression* exp) : expression_(exp) {}
   virtual ~ExpressionStatement();
 
   DEFINE_CASTING_OPERATIONS(ExpressionStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* expression() { return expression_; }
 
  private:
   ExpressionStatement() {}
 
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpressionStatement);
 };
 
 
 class Block : public Statement {
  public:
   static Block* ReadFromImpl(Reader* reader);
-  virtual void WriteTo(Writer* writer);
-  void WriteToImpl(Writer* writer);
 
   virtual ~Block();
 
   DEFINE_CASTING_OPERATIONS(Block);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   List<Statement>& statements() { return statements_; }
 
  private:
   Block() {}
 
   List<Statement> statements_;
 
   DISALLOW_COPY_AND_ASSIGN(Block);
 };
 
 
 class EmptyStatement : public Statement {
  public:
   static EmptyStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~EmptyStatement();
 
   DEFINE_CASTING_OPERATIONS(EmptyStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
  private:
   EmptyStatement() {}
 
   DISALLOW_COPY_AND_ASSIGN(EmptyStatement);
 };
 
 
 class AssertStatement : public Statement {
  public:
   static AssertStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~AssertStatement();
 
   DEFINE_CASTING_OPERATIONS(AssertStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* condition() { return condition_; }
   Expression* message() { return message_; }
 
  private:
   AssertStatement() {}
 
   Child<Expression> condition_;
   Child<Expression> message_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertStatement);
 };
 
 
 class LabeledStatement : public Statement {
  public:
   static LabeledStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~LabeledStatement();
 
   DEFINE_CASTING_OPERATIONS(LabeledStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Statement* body() { return body_; }
 
  private:
   LabeledStatement() {}
 
   Child<Statement> body_;
 
   DISALLOW_COPY_AND_ASSIGN(LabeledStatement);
 };
 
 
 class BreakStatement : public Statement {
  public:
   static BreakStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~BreakStatement();
 
   DEFINE_CASTING_OPERATIONS(BreakStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   LabeledStatement* target() { return target_; }
 
  private:
   BreakStatement() {}
 
   Ref<LabeledStatement> target_;
 
   DISALLOW_COPY_AND_ASSIGN(BreakStatement);
 };
 
 
 class WhileStatement : public Statement {
  public:
   static WhileStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~WhileStatement();
 
   DEFINE_CASTING_OPERATIONS(WhileStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* condition() { return condition_; }
   Statement* body() { return body_; }
 
  private:
   WhileStatement() {}
 
   Child<Expression> condition_;
   Child<Statement> body_;
 
   DISALLOW_COPY_AND_ASSIGN(WhileStatement);
 };
 
 
 class DoStatement : public Statement {
  public:
   static DoStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~DoStatement();
 
   DEFINE_CASTING_OPERATIONS(DoStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* condition() { return condition_; }
   Statement* body() { return body_; }
 
  private:
   DoStatement() {}
 
   Child<Expression> condition_;
   Child<Statement> body_;
 
   DISALLOW_COPY_AND_ASSIGN(DoStatement);
 };
 
 
 class ForStatement : public Statement {
  public:
   static ForStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~ForStatement();
 
   DEFINE_CASTING_OPERATIONS(ForStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   List<VariableDeclaration>& variables() { return variables_; }
   Expression* condition() { return condition_; }
   List<Expression>& updates() { return updates_; }
   Statement* body() { return body_; }
 
  private:
   ForStatement() {}
 
   List<VariableDeclaration> variables_;
   Child<Expression> condition_;
   List<Expression> updates_;
   Child<Statement> body_;
 
   DISALLOW_COPY_AND_ASSIGN(ForStatement);
 };
 
 
 class ForInStatement : public Statement {
  public:
   static ForInStatement* ReadFrom(Reader* reader, bool is_async);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~ForInStatement();
 
   DEFINE_CASTING_OPERATIONS(ForInStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   Expression* iterable() { return iterable_; }
   Statement* body() { return body_; }
   bool is_async() { return is_async_; }
 
  private:
   ForInStatement() {}
 
   Child<VariableDeclaration> variable_;
   Child<Expression> iterable_;
   Child<Statement> body_;
   bool is_async_;
 
   DISALLOW_COPY_AND_ASSIGN(ForInStatement);
 };
 
 
 class SwitchStatement : public Statement {
  public:
   static SwitchStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~SwitchStatement();
 
   DEFINE_CASTING_OPERATIONS(SwitchStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* condition() { return condition_; }
   List<SwitchCase>& cases() { return cases_; }
 
  private:
   SwitchStatement() {}
 
   Child<Expression> condition_;
   List<SwitchCase> cases_;
 
   DISALLOW_COPY_AND_ASSIGN(SwitchStatement);
 };
 
 
 class SwitchCase : public TreeNode {
  public:
   SwitchCase* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~SwitchCase();
 
   DEFINE_CASTING_OPERATIONS(SwitchCase);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   List<Expression>& expressions() { return expressions_; }
   bool is_default() { return is_default_; }
   Statement* body() { return body_; }
 
  private:
   SwitchCase() {}
 
   template <typename T>
   friend class List;
 
   List<Expression> expressions_;
   bool is_default_;
   Child<Statement> body_;
 
   DISALLOW_COPY_AND_ASSIGN(SwitchCase);
 };
 
 
 class ContinueSwitchStatement : public Statement {
  public:
   static ContinueSwitchStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~ContinueSwitchStatement();
 
   DEFINE_CASTING_OPERATIONS(ContinueSwitchStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   SwitchCase* target() { return target_; }
 
  private:
   ContinueSwitchStatement() {}
 
   Ref<SwitchCase> target_;
 
   DISALLOW_COPY_AND_ASSIGN(ContinueSwitchStatement);
 };
 
 
 class IfStatement : public Statement {
  public:
   static IfStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~IfStatement();
 
   DEFINE_CASTING_OPERATIONS(IfStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* condition() { return condition_; }
   Statement* then() { return then_; }
   Statement* otherwise() { return otherwise_; }
 
  private:
   IfStatement() {}
 
   Child<Expression> condition_;
   Child<Statement> then_;
   Child<Statement> otherwise_;
 
   DISALLOW_COPY_AND_ASSIGN(IfStatement);
 };
 
 
 class ReturnStatement : public Statement {
  public:
   static ReturnStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~ReturnStatement();
 
   DEFINE_CASTING_OPERATIONS(ReturnStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Expression* expression() { return expression_; }
 
  private:
   ReturnStatement() {}
 
   Child<Expression> expression_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnStatement);
 };
 
 
 class TryCatch : public Statement {
  public:
   static TryCatch* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~TryCatch();
 
   DEFINE_CASTING_OPERATIONS(TryCatch);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Statement* body() { return body_; }
   List<Catch>& catches() { return catches_; }
 
  private:
   TryCatch() {}
 
   Child<Statement> body_;
   List<Catch> catches_;
 
   DISALLOW_COPY_AND_ASSIGN(TryCatch);
 };
 
 
 class Catch : public TreeNode {
  public:
   static Catch* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Catch();
 
   DEFINE_CASTING_OPERATIONS(Catch);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   DartType* guard() { return guard_; }
   VariableDeclaration* exception() { return exception_; }
@@ skipping 11 matching lines @@
   Child<VariableDeclaration> stack_trace_;
   Child<Statement> body_;
 
   DISALLOW_COPY_AND_ASSIGN(Catch);
 };
 
 
 class TryFinally : public Statement {
  public:
   static TryFinally* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~TryFinally();
 
   DEFINE_CASTING_OPERATIONS(TryFinally);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Statement* body() { return body_; }
   Statement* finalizer() { return finalizer_; }
 
  private:
   TryFinally() {}
 
   Child<Statement> body_;
   Child<Statement> finalizer_;
 
   DISALLOW_COPY_AND_ASSIGN(TryFinally);
 };
 
 
 class YieldStatement : public Statement {
  public:
   enum {
     kFlagYieldStar = 1 << 0,
     kFlagNative = 1 << 1,
   };
   static YieldStatement* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~YieldStatement();
 
   DEFINE_CASTING_OPERATIONS(YieldStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool is_yield_start() { return (flags_ & kFlagYieldStar) == kFlagYieldStar; }
   bool is_native() { return (flags_ & kFlagNative) == kFlagNative; }
@@ skipping 11 matching lines @@
 
 class VariableDeclaration : public Statement {
  public:
   enum Flags {
     kFlagFinal = 1 << 0,
     kFlagConst = 1 << 1,
   };
 
   static VariableDeclaration* ReadFrom(Reader* reader);
   static VariableDeclaration* ReadFromImpl(Reader* reader);
-  virtual void WriteTo(Writer* writer);
-  void WriteToImpl(Writer* writer);
 
   virtual ~VariableDeclaration();
 
   DEFINE_CASTING_OPERATIONS(VariableDeclaration);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; }
@@ skipping 15 matching lines @@
   Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableDeclaration);
 };
 
 
 class FunctionDeclaration : public Statement {
  public:
   static FunctionDeclaration* ReadFrom(Reader* reader);
-  virtual void WriteTo(Writer* writer);
 
   virtual ~FunctionDeclaration();
 
   DEFINE_CASTING_OPERATIONS(FunctionDeclaration);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   FunctionNode* function() { return function_; }
 
  private:
   FunctionDeclaration() {}
 
   Child<VariableDeclaration> variable_;
   Child<FunctionNode> function_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionDeclaration);
 };
 
 
 class Name : public Node {
  public:
   static Name* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Name();
 
   DEFINE_CASTING_OPERATIONS(Name);
 
   virtual void AcceptVisitor(Visitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* string() { return string_; }
   Library* library() { return library_; }
 
  private:
-  Name(String* string, Library* library) : string_(string), library_(library) {}
+  Name(String* string, Library* library)
+      : string_(string), library_(library) {}  // NOLINT
 
   Ref<String> string_;
   Ref<Library> library_;
 
   DISALLOW_COPY_AND_ASSIGN(Name);
 };
 
 
 class InferredValue : public Node {
  public:
   static const uint8_t kNull = 1 << 0;
   static const uint8_t kInteger = 1 << 1;
   static const uint8_t kDouble = 1 << 2;
   static const uint8_t kString = 1 << 3;
   static const uint8_t kOther = 1 << 4;
 
   enum BaseClassKind {
     kNone,
     kExact,
     kSubclass,
     kSubtype,
   };
 
   static InferredValue* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~InferredValue();
 
   DEFINE_CASTING_OPERATIONS(InferredValue);
 
   virtual void AcceptVisitor(Visitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsInterfaceType() { return kind_ == kSubtype; }
   bool IsExactClass() { return kind_ == kExact; }
@@ skipping 20 matching lines @@
   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() {}
 
  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() {}
 
   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() {}
 
   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() {}
 
   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);
 
   explicit InterfaceType(Class* klass) : klass_(klass) {}
   virtual ~InterfaceType();
 
   DEFINE_CASTING_OPERATIONS(InterfaceType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Class* klass() { return klass_; }
   List<DartType>& type_arguments() { return type_arguments_; }
 
  private:
   InterfaceType() {}
 
   Ref<Class> klass_;
   List<DartType> type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceType);
 };
 
 
 class FunctionType : public DartType {
  public:
   static FunctionType* ReadFrom(Reader* reader);
   static FunctionType* ReadFrom(Reader* reader, bool _without_type_arguments_);
-  void WriteTo(Writer* writer);
 
   virtual ~FunctionType();
 
   DEFINE_CASTING_OPERATIONS(FunctionType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   TypeParameterList& type_parameters() { return type_parameters_; }
   int required_parameter_count() { return required_parameter_count_; }
@@ skipping 12 matching lines @@
   List<Tuple<String, DartType> > named_parameters_;
   Child<DartType> return_type_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionType);
 };
 
 
 class TypeParameterType : public DartType {
  public:
   static TypeParameterType* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~TypeParameterType();
 
   DEFINE_CASTING_OPERATIONS(TypeParameterType);
 
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   TypeParameter* parameter() { return parameter_; }
 
  private:
   TypeParameterType() {}
 
   Ref<TypeParameter> parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeParameterType);
 };
 
 
 class TypeParameter : public TreeNode {
  public:
   TypeParameter* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~TypeParameter();
 
   DEFINE_CASTING_OPERATIONS(TypeParameter);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* name() { return name_; }
   DartType* bound() { return bound_; }
 
  private:
   TypeParameter() {}
 
   template <typename T>
   friend class List;
   friend class TypeParameterList;
 
   Ref<String> name_;
   Child<DartType> bound_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeParameter);
 };
 
 
 class Program : public TreeNode {
  public:
   static Program* ReadFrom(Reader* reader);
-  void WriteTo(Writer* writer);
 
   virtual ~Program();
 
   DEFINE_CASTING_OPERATIONS(Program);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   StringTable& string_table() { return string_table_; }
   StringTable& source_uri_table() { return source_uri_table_; }
@@ skipping 10 matching lines @@
   StringTable source_uri_table_;
   SourceTable source_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,
-                            bool allow_null = false);
 
   static Class* ReadClassFrom(Reader* reader, bool allow_null = false);
-  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() {}
 
   virtual void VisitDefaultExpression(Expression* node) = 0;
   virtual void VisitDefaultBasicLiteral(BasicLiteral* node) {
     VisitDefaultExpression(node);
@@ skipping 397 matching lines @@
 }
 
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone,
                                             const dart::Field& field);
 
 }  // namespace kernel
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length);
 
-class ByteWriter {
- public:
-  virtual ~ByteWriter();
-
-  virtual void WriteByte(uint8_t byte) = 0;
-
-  virtual void WriteBytes(uint8_t* buffer, int count) = 0;
-};
-
-
-void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program);
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_