Add typedef AST node boilerplate.

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"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/token_position.h"
 
 
 #define KERNEL_NODES_DO(M)                                                     \
   M(Name)                                                                      \
   M(DartType)                                                                  \
   M(InvalidType)                                                               \
   M(DynamicType)                                                               \
   M(VoidType)                                                                  \
   M(InterfaceType)                                                             \
   M(FunctionType)                                                              \
   M(TypeParameterType)                                                         \
-  M(VectorType)
+  M(VectorType)                                                                \
+  M(TypedefType)
 
 #define KERNEL_TREE_NODES_DO(M)                                                \
   M(Library)                                                                   \
+  M(Typedef)                                                                   \
   M(Class)                                                                     \
   M(NormalClass)                                                               \
   M(MixinClass)                                                                \
   M(Member)                                                                    \
   M(Field)                                                                     \
   M(Constructor)                                                               \
   M(Procedure)                                                                 \
   M(Initializer)                                                               \
   M(InvalidInitializer)                                                        \
   M(FieldInitializer)                                                          \
@@ skipping 329 matching lines @@
   virtual Node::NodeType Type() { return Node::kType##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)                                                \
   KERNEL_TREE_NODES_DO(DEFINE_IS_OPERATION)
 
+class Typedef;
 class Class;
 class Constructor;
 class Field;
 class Library;
 class LinkedNode;
 class Member;
 class Procedure;
 
 class CanonicalName {
  public:
@@ skipping 93 matching lines @@
   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_; }
   String* name() { return name_; }
+  List<Typedef>& typedefs() { return typedefs_; }
   List<Class>& classes() { return classes_; }
   List<Field>& fields() { return fields_; }
   List<Procedure>& procedures() { return procedures_; }
 
   const uint8_t* kernel_data() { return kernel_data_; }
   intptr_t kernel_data_size() { return kernel_data_size_; }
 
  private:
   Library() : name_(NULL), kernel_data_(NULL), kernel_data_size_(-1) {}
 
   template <typename T>
   friend class List;
 
   Ref<String> name_;
   Ref<String> import_uri_;
   intptr_t source_uri_index_;
+  List<Typedef> typedefs_;
   List<Class> classes_;
   List<Field> fields_;
   List<Procedure> procedures_;
   const uint8_t* kernel_data_;
   intptr_t kernel_data_size_;
 
   DISALLOW_COPY_AND_ASSIGN(Library);
 };
 
 
+class Typedef : public LinkedNode {
+ public:
+  Typedef* ReadFrom(Reader* reader);
+
+  virtual ~Typedef();
+
+  DEFINE_CASTING_OPERATIONS(Typedef);
+
+  virtual void AcceptTreeVisitor(TreeVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  Library* parent() { return parent_; }
+  String* name() { return name_; }
+  intptr_t source_uri_index() { return source_uri_index_; }
+  TokenPosition position() { return position_; }
+  TypeParameterList& type_parameters() { return type_parameters_; }
+  DartType* type() { return type_; }
+
+ protected:
+  Typedef() : position_(TokenPosition::kNoSource) {}
+
+ private:
+  template <typename T>
+  friend class List;
+
+  Ref<Library> parent_;
+  Ref<String> name_;
+  intptr_t source_uri_index_;
+  TokenPosition position_;
+  TypeParameterList type_parameters_;
+  Child<DartType> type_;
+};
+
+
 class Class : public LinkedNode {
  public:
   Class* ReadFrom(Reader* reader);
 
   virtual ~Class();
 
   DEFINE_CASTING_OPERATIONS(Class);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptClassVisitor(ClassVisitor* visitor) = 0;
@@ skipping 2221 matching lines @@
  private:
   InterfaceType() {}
 
   Ref<CanonicalName> class_reference_;  // Class.
   List<DartType> type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceType);
 };
 
 
+class TypedefType : public DartType {
+ public:
+  static TypedefType* ReadFrom(Reader* reader);
+
+  explicit TypedefType(CanonicalName* class_reference)
+      : typedef_reference_(class_reference) {}
+  virtual ~TypedefType();
+
+  DEFINE_CASTING_OPERATIONS(TypedefType);
+
+  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  CanonicalName* typedef_reference() { return typedef_reference_; }
+  List<DartType>& type_arguments() { return type_arguments_; }
+
+ private:
+  TypedefType() {}
+
+  Ref<CanonicalName> typedef_reference_;  // Typedef.
+  List<DartType> type_arguments_;
+
+  DISALLOW_COPY_AND_ASSIGN(TypedefType);
+};
+
+
 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);
@@ skipping 124 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Program);
 };
 
 
 class Reference : public AllStatic {
  public:
   static CanonicalName* ReadMemberFrom(Reader* reader, bool allow_null = false);
 
   static CanonicalName* ReadClassFrom(Reader* reader, bool allow_null = false);
 
+  static CanonicalName* ReadTypedefFrom(Reader* reader);
+
   static String* ReadStringFrom(Reader* reader);
 };
 
 
 class ExpressionVisitor {
  public:
   virtual ~ExpressionVisitor() {}
 
   virtual void VisitDefaultExpression(Expression* node) = 0;
   virtual void VisitDefaultBasicLiteral(BasicLiteral* node) {
@@ skipping 229 matching lines @@
   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);
+  }
 };
 
 
 class TreeVisitor : public ExpressionVisitor,
                     public StatementVisitor,
                     public MemberVisitor,
                     public ClassVisitor,
                     public InitializerVisitor {
  public:
   virtual ~TreeVisitor() {}
@@ skipping 19 matching lines @@
     VisitDefaultTreeNode(node);
   }
   virtual void VisitArguments(Arguments* node) { VisitDefaultTreeNode(node); }
   virtual void VisitNamedExpression(NamedExpression* node) {
     VisitDefaultTreeNode(node);
   }
   virtual void VisitSwitchCase(SwitchCase* node) { VisitDefaultTreeNode(node); }
   virtual void VisitCatch(Catch* node) { VisitDefaultTreeNode(node); }
   virtual void VisitMapEntry(MapEntry* node) { VisitDefaultTreeNode(node); }
   virtual void VisitProgram(Program* node) { VisitDefaultTreeNode(node); }
+  virtual void VisitTypedef(Typedef* node) { VisitDefaultTreeNode(node); }
 };
 
 
 class Visitor : public TreeVisitor, public DartTypeVisitor {
  public:
   virtual ~Visitor() {}
 
   virtual void VisitDefaultNode(Node* node) = 0;
   virtual void VisitDefaultTreeNode(TreeNode* node) { VisitDefaultNode(node); }
   virtual void VisitDefaultDartType(DartType* node) { VisitDefaultNode(node); }
@@ skipping 90 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_