Index: runtime/vm/kernel.h |
diff --git a/runtime/vm/kernel.h b/runtime/vm/kernel.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..b6038fc2d119a3b240f720e93b8a158340ca0e3c |
--- /dev/null |
+++ b/runtime/vm/kernel.h |
@@ -0,0 +1,3243 @@ |
+// 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 VM_KERNEL_H_ |
+#define VM_KERNEL_H_ |
+ |
+#include "platform/assert.h" |
+#include "vm/allocation.h" |
+#include "vm/globals.h" |
+ |
+#define KERNEL_NODES_DO(M) \ |
+ M(Name) \ |
+ M(InferredValue) \ |
+ M(DartType) \ |
+ M(InvalidType) \ |
+ M(DynamicType) \ |
+ M(VoidType) \ |
+ M(InterfaceType) \ |
+ M(FunctionType) \ |
+ M(TypeParameterType) |
+ |
+#define KERNEL_TREE_NODES_DO(M) \ |
+ M(Library) \ |
+ M(Class) \ |
+ M(NormalClass) \ |
+ M(MixinClass) \ |
+ M(Member) \ |
+ M(Field) \ |
+ M(Constructor) \ |
+ M(Procedure) \ |
+ M(Initializer) \ |
+ M(InvalidInitializer) \ |
+ M(FieldInitializer) \ |
+ M(SuperInitializer) \ |
+ M(RedirectingInitializer) \ |
+ M(LocalInitializer) \ |
+ M(FunctionNode) \ |
+ M(Expression) \ |
+ M(InvalidExpression) \ |
+ M(VariableGet) \ |
+ M(VariableSet) \ |
+ M(PropertyGet) \ |
+ M(PropertySet) \ |
+ M(DirectPropertyGet) \ |
+ M(DirectPropertySet) \ |
+ M(StaticGet) \ |
+ M(StaticSet) \ |
+ M(Arguments) \ |
+ M(NamedExpression) \ |
+ M(MethodInvocation) \ |
+ M(DirectMethodInvocation) \ |
+ M(StaticInvocation) \ |
+ M(ConstructorInvocation) \ |
+ M(Not) \ |
+ M(LogicalExpression) \ |
+ M(ConditionalExpression) \ |
+ M(StringConcatenation) \ |
+ M(IsExpression) \ |
+ M(AsExpression) \ |
+ M(BasicLiteral) \ |
+ M(StringLiteral) \ |
+ M(BigintLiteral) \ |
+ M(IntLiteral) \ |
+ M(DoubleLiteral) \ |
+ M(BoolLiteral) \ |
+ M(NullLiteral) \ |
+ M(SymbolLiteral) \ |
+ M(TypeLiteral) \ |
+ M(ThisExpression) \ |
+ M(Rethrow) \ |
+ M(Throw) \ |
+ M(ListLiteral) \ |
+ M(MapLiteral) \ |
+ M(MapEntry) \ |
+ M(AwaitExpression) \ |
+ M(FunctionExpression) \ |
+ M(Let) \ |
+ M(BlockExpression) \ |
+ M(Statement) \ |
+ M(InvalidStatement) \ |
+ M(ExpressionStatement) \ |
+ M(Block) \ |
+ M(EmptyStatement) \ |
+ M(AssertStatement) \ |
+ M(LabeledStatement) \ |
+ M(BreakStatement) \ |
+ M(WhileStatement) \ |
+ M(DoStatement) \ |
+ M(ForStatement) \ |
+ M(ForInStatement) \ |
+ M(SwitchStatement) \ |
+ M(SwitchCase) \ |
+ M(ContinueSwitchStatement) \ |
+ M(IfStatement) \ |
+ M(ReturnStatement) \ |
+ M(TryCatch) \ |
+ M(Catch) \ |
+ M(TryFinally) \ |
+ M(YieldStatement) \ |
+ M(VariableDeclaration) \ |
+ M(FunctionDeclaration) \ |
+ M(TypeParameter) \ |
+ 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(StatementVisitor) \ |
+ M(MemberVisitor) \ |
+ M(ClassVisitor) \ |
+ M(InitializerVisitor) \ |
+ M(DartTypeVisitor) \ |
+ M(ClassReferenceVisitor) \ |
+ M(MemberReferenceVisitor) \ |
+ M(TreeVisitor) \ |
+ M(Visitor) |
+ |
+namespace dart { |
+ |
+namespace kernel { |
+ |
+ |
+class Reader; |
+class TreeNode; |
+class TypeParameter; |
+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_; } |
+ |
+ // Support `Child<T> box = T* obj`. |
+ T*& operator=(T* value) { |
+ ASSERT(pointer_ == NULL); |
+ return pointer_ = value; |
+ } |
+ |
+ // Implicitly convert `Child<T>` to `T*`. |
+ operator T*&() { return pointer_; } |
+ |
+ T* operator->() { return pointer_; } |
+ |
+ private: |
+ T* pointer_; |
+}; |
+ |
+// Boxes a value of type `T*` (only used to mark a member as a weak reference). |
+template <typename T> |
+class Ref { |
+ public: |
+ Ref() : pointer_(NULL) {} |
+ explicit Ref(T* value) : pointer_(value) {} |
+ |
+ // Support `Ref<T> box = T* obj`. |
+ T*& operator=(T* value) { |
+ ASSERT(pointer_ == NULL); |
+ return pointer_ = value; |
+ } |
+ |
+ // Implicitly convert `Ref<T>` to `T*`. |
+ operator T*&() { return pointer_; } |
+ |
+ T* operator->() { return pointer_; } |
+ |
+ private: |
+ T* pointer_; |
+}; |
+ |
+ |
+template <typename T> |
+class List { |
+ public: |
+ List() : array_(NULL), length_(0) {} |
+ ~List(); |
+ |
+ 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> |
+ IT* GetOrCreate(int index); |
+ |
+ template <typename IT, typename PT> |
+ IT* GetOrCreate(int index, PT* parent); |
+ |
+ // Returns element at [index]. |
+ T*& operator[](int index) { |
+ ASSERT(index < length_); |
+ return array_[index]; |
+ } |
+ |
+ int length() { return length_; } |
+ |
+ T** raw_array() { return array_; } |
+ |
+ private: |
+ 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 LineStartingTable { |
+ public: |
+ void ReadFrom(Reader* reader, intptr_t length); |
+ void WriteTo(Writer* writer); |
+ ~LineStartingTable() { |
+ for (intptr_t i = 0; i < size_; ++i) { |
+ delete[] values_[i]; |
+ } |
+ delete[] values_; |
+ } |
+ |
+ intptr_t size() { return size_; } |
+ intptr_t* valuesFor(int i) { return values_[i]; } |
+ |
+ private: |
+ LineStartingTable() : values_(NULL), size_(0) {} |
+ |
+ friend class Program; |
+ |
+ intptr_t** values_; |
+ intptr_t size_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(LineStartingTable); |
+}; |
+ |
+// Forward declare all classes. |
+#define DO(name) class name; |
+KERNEL_ALL_NODES_DO(DO) |
+KERNEL_VISITORS_DO(DO) |
+#undef DO |
+ |
+ |
+#define DEFINE_CASTING_OPERATIONS(klass) \ |
+ virtual bool Is##klass() { return true; } \ |
+ \ |
+ static klass* Cast(Node* node) { \ |
+ ASSERT(node == NULL || node->Is##klass()); \ |
+ return static_cast<klass*>(node); \ |
+ } \ |
+ \ |
+ 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 Node { |
+ public: |
+ virtual ~Node(); |
+ |
+ enum NodeType { |
+#define DO(name) kType##name, |
+ KERNEL_ALL_NODES_DO(DO) |
+#undef DO |
+ |
+ kNumTypes |
+ }; |
+ |
+ DEFINE_ALL_IS_OPERATIONS(); |
+ DEFINE_CASTING_OPERATIONS(Node); |
+ |
+ virtual void AcceptVisitor(Visitor* visitor) = 0; |
+ virtual void VisitChildren(Visitor* visitor) = 0; |
+ |
+ protected: |
+ Node() { } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(Node); |
+}; |
+ |
+ |
+class TreeNode : public Node { |
+ public: |
+ virtual ~TreeNode(); |
+ |
+ DEFINE_CASTING_OPERATIONS(TreeNode); |
+ |
+ virtual void AcceptVisitor(Visitor* visitor); |
+ virtual void AcceptTreeVisitor(TreeVisitor* visitor) = 0; |
+ |
+ protected: |
+ 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_; } |
+ String* name() { return name_; } |
+ List<Class>& classes() { return classes_; } |
+ List<Field>& fields() { return fields_; } |
+ List<Procedure>& procedures() { return procedures_; } |
+ |
+ bool IsCorelibrary() { |
+ static const char* dart_library = "dart:"; |
+ static intptr_t dart_library_length = strlen(dart_library); |
+ static const char* patch_library = "dart:_patch"; |
+ static intptr_t patch_library_length = strlen(patch_library); |
+ |
+ if (name_->size() < 5) return false; |
+ |
+ // Check for dart: prefix. |
+ char* buffer = reinterpret_cast<char*>(import_uri_->buffer()); |
+ if (strncmp(buffer, dart_library, dart_library_length) != 0) { |
+ return false; |
+ } |
+ |
+ // Rasta emits dart:_patch and we should treat it as a user library. |
+ if (name_->size() == patch_library_length && |
+ strncmp(buffer, patch_library, patch_library_length) == 0) { |
+ return false; |
+ } |
+ return true; |
+ } |
+ |
+ private: |
+ Library() : name_(NULL) {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ Ref<String> name_; |
+ Ref<String> import_uri_; |
+ List<Class> classes_; |
+ 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_; } |
+ String* name() { return name_; } |
+ bool is_abstract() { return is_abstract_; } |
+ List<Expression>& annotations() { return annotations_; } |
+ |
+ virtual List<TypeParameter>& type_parameters() = 0; |
+ virtual List<InterfaceType>& implemented_classes() = 0; |
+ virtual List<Field>& fields() = 0; |
+ virtual List<Constructor>& constructors() = 0; |
+ virtual List<Procedure>& procedures() = 0; |
+ |
+ protected: |
+ Class() : is_abstract_(false) {} |
+ |
+ private: |
+ template <typename T> |
+ friend class List; |
+ |
+ Ref<Library> parent_; |
+ Ref<String> name_; |
+ bool is_abstract_; |
+ List<Expression> annotations_; |
+ |
+ 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_; } |
+ InterfaceType* super_class() { return super_class_; } |
+ virtual List<InterfaceType>& implemented_classes() { |
+ return implemented_classes_; |
+ } |
+ virtual List<Constructor>& constructors() { return constructors_; } |
+ virtual List<Procedure>& procedures() { return procedures_; } |
+ virtual List<Field>& fields() { return fields_; } |
+ |
+ private: |
+ NormalClass() {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ TypeParameterList type_parameters_; |
+ Child<InterfaceType> super_class_; |
+ List<InterfaceType> implemented_classes_; |
+ List<Constructor> constructors_; |
+ 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_; } |
+ InterfaceType* first() { return first_; } |
+ InterfaceType* second() { return second_; } |
+ virtual List<InterfaceType>& implemented_classes() { |
+ return implemented_classes_; |
+ } |
+ virtual List<Constructor>& constructors() { return constructors_; } |
+ virtual List<Field>& fields() { return fields_; } |
+ virtual List<Procedure>& procedures() { return procedures_; } |
+ |
+ private: |
+ MixinClass() {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ TypeParameterList type_parameters_; |
+ Child<InterfaceType> first_; |
+ Child<InterfaceType> second_; |
+ List<InterfaceType> implemented_classes_; |
+ List<Constructor> constructors_; |
+ |
+ // Dummy instances which are empty lists. |
+ List<Field> fields_; |
+ List<Procedure> procedures_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(MixinClass); |
+}; |
+ |
+ |
+class Member : public TreeNode { |
+ public: |
+ virtual ~Member(); |
+ |
+ DEFINE_CASTING_OPERATIONS(Member); |
+ |
+ virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
+ virtual void AcceptMemberVisitor(MemberVisitor* visitor) = 0; |
+ virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor) = 0; |
+ |
+ TreeNode* parent() { return parent_; } |
+ Name* name() { return name_; } |
+ List<Expression>& annotations() { return annotations_; } |
+ |
+ protected: |
+ Member() { } |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ Ref<TreeNode> parent_; |
+ Child<Name> name_; |
+ List<Expression> annotations_; |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(Member); |
+}; |
+ |
+ |
+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; } |
+ bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; } |
+ bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; } |
+ |
+ DartType* type() { return type_; } |
+ InferredValue* inferred_value() { return inferred_value_; } |
+ Expression* initializer() { return initializer_; } |
+ |
+ private: |
+ Field() {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ word flags_; |
+ Child<DartType> type_; |
+ Child<InferredValue> inferred_value_; |
+ Child<Expression> initializer_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(Field); |
+}; |
+ |
+ |
+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; } |
+ bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; } |
+ |
+ FunctionNode* function() { return function_; } |
+ List<Initializer>& initializers() { return initializers_; } |
+ |
+ private: |
+ template <typename T> |
+ friend class List; |
+ |
+ Constructor() {} |
+ |
+ uint8_t flags_; |
+ Child<FunctionNode> function_; |
+ List<Initializer> initializers_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(Constructor); |
+}; |
+ |
+ |
+class Procedure : public Member { |
+ public: |
+ enum Flags { |
+ kFlagStatic = 1 << 0, |
+ kFlagAbstract = 1 << 1, |
+ kFlagExternal = 1 << 2, |
+ kFlagConst = 1 << 3, // Only for external const factories. |
+ }; |
+ |
+ // Keep in sync with package:dynamo/lib/ast.dart:ProcedureKind |
+ enum ProcedureKind { |
+ 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_; } |
+ FunctionNode* function() { return function_; } |
+ |
+ bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; } |
+ bool IsAbstract() { return (flags_ & kFlagAbstract) == kFlagAbstract; } |
+ bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; } |
+ bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; } |
+ |
+ private: |
+ Procedure() : kind_(kIncompleteProcedure), flags_(0), function_(NULL) {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ ProcedureKind kind_; |
+ word flags_; |
+ 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_; } |
+ |
+ private: |
+ LocalInitializer() {} |
+ |
+ Child<VariableDeclaration> variable_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(LocalInitializer); |
+}; |
+ |
+ |
+class FunctionNode : public TreeNode { |
+ 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_; } |
+ TypeParameterList& type_parameters() { return type_parameters_; } |
+ int required_parameter_count() { return required_parameter_count_; } |
+ List<VariableDeclaration>& positional_parameters() { |
+ return positional_parameters_; |
+ } |
+ List<VariableDeclaration>& named_parameters() { return named_parameters_; } |
+ DartType* return_type() { return return_type_; } |
+ InferredValue* inferred_return_value() { return inferred_return_value_; } |
+ Statement* body() { return body_; } |
+ |
+ private: |
+ FunctionNode() {} |
+ |
+ AsyncMarker async_marker_; |
+ TypeParameterList type_parameters_; |
+ int required_parameter_count_; |
+ List<VariableDeclaration> positional_parameters_; |
+ List<VariableDeclaration> named_parameters_; |
+ Child<DartType> return_type_; |
+ Child<InferredValue> inferred_return_value_; |
+ Child<Statement> body_; |
+ |
+ 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; |
+ |
+ protected: |
+ Expression() { } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(Expression); |
+}; |
+ |
+ |
+class InvalidExpression : public Expression { |
+ public: |
+ static InvalidExpression* ReadFrom(Reader* reader); |
+ virtual void WriteTo(Writer* writer); |
+ |
+ virtual ~InvalidExpression(); |
+ virtual void VisitChildren(Visitor* visitor); |
+ |
+ DEFINE_CASTING_OPERATIONS(InvalidExpression); |
+ |
+ virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
+ |
+ private: |
+ InvalidExpression() { } |
+ |
+ 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); |
+ |
+ explicit StaticInvocation(Procedure* procedure, Arguments* args, |
+ bool is_const) |
+ : procedure_(procedure), arguments_(args), is_const_(is_const) {} |
+ ~StaticInvocation(); |
+ |
+ virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
+ virtual void VisitChildren(Visitor* visitor); |
+ |
+ Procedure* procedure() { return procedure_; } |
+ Arguments* arguments() { return arguments_; } |
+ bool is_const() { return is_const_; } |
+ |
+ 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_; } |
+ |
+ private: |
+ AsExpression() {} |
+ |
+ Child<Expression> operand_; |
+ Child<DartType> type_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(AsExpression); |
+}; |
+ |
+ |
+class BasicLiteral : public Expression { |
+ public: |
+ virtual ~BasicLiteral(); |
+ |
+ 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_; } |
+ |
+ private: |
+ Let() {} |
+ |
+ Child<VariableDeclaration> variable_; |
+ Child<Expression> body_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(Let); |
+}; |
+ |
+ |
+class BlockExpression : public Expression { |
+ public: |
+ static BlockExpression* ReadFrom(Reader* reader); |
+ virtual void WriteTo(Writer* writer); |
+ |
+ virtual ~BlockExpression(); |
+ |
+ DEFINE_CASTING_OPERATIONS(BlockExpression); |
+ |
+ virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
+ virtual void VisitChildren(Visitor* visitor); |
+ |
+ Block* body() { return body_; } |
+ Expression* value() { return value_; } |
+ |
+ private: |
+ BlockExpression() {} |
+ |
+ Child<Block> body_; |
+ Child<Expression> value_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(BlockExpression); |
+}; |
+ |
+ |
+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; |
+ |
+ protected: |
+ Statement() { } |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(Statement); |
+}; |
+ |
+ |
+class InvalidStatement : public Statement { |
+ public: |
+ static InvalidStatement* ReadFrom(Reader* reader); |
+ virtual void WriteTo(Writer* writer); |
+ |
+ virtual ~InvalidStatement(); |
+ |
+ DEFINE_CASTING_OPERATIONS(InvalidStatement); |
+ |
+ virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
+ virtual void VisitChildren(Visitor* visitor); |
+ |
+ private: |
+ InvalidStatement() { } |
+ |
+ 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_; } |
+ VariableDeclaration* stack_trace() { return stack_trace_; } |
+ Statement* body() { return body_; } |
+ |
+ private: |
+ Catch() {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ Child<DartType> guard_; |
+ Child<VariableDeclaration> exception_; |
+ 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; } |
+ Expression* expression() { return expression_; } |
+ |
+ private: |
+ YieldStatement() {} |
+ |
+ word flags_; |
+ Child<Expression> expression_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(YieldStatement); |
+}; |
+ |
+ |
+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; } |
+ |
+ String* name() { return name_; } |
+ DartType* type() { return type_; } |
+ InferredValue* inferred_value() { return inferred_value_; } |
+ Expression* initializer() { return initializer_; } |
+ |
+ private: |
+ VariableDeclaration() {} |
+ |
+ template <typename T> |
+ friend class List; |
+ |
+ word flags_; |
+ Ref<String> name_; |
+ Child<DartType> type_; |
+ 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) {} |
+ |
+ 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; } |
+ bool IsSubclass() { return kind_ == kSubclass; } |
+ |
+ bool CanBeNull() { return (value_bits_ & kNull) != 0; } |
+ bool CanBeInteger() { return (value_bits_ & kInteger) != 0; } |
+ bool CanBeDouble() { return (value_bits_ & kDouble) != 0; } |
+ bool CanBeString() { return (value_bits_ & kString) != 0; } |
+ |
+ bool IsAlwaysNull() { return value_bits_ == kNull; } |
+ bool IsAlwaysInteger() { return value_bits_ == kInteger; } |
+ bool IsAlwaysDouble() { return value_bits_ == kDouble; } |
+ bool IsAlwaysString() { return value_bits_ == kString; } |
+ |
+ Class* klass() { return klass_; } |
+ BaseClassKind kind() { return kind_; } |
+ uint8_t value_bits() { return value_bits_; } |
+ |
+ private: |
+ InferredValue() { } |
+ |
+ Ref<Class> klass_; |
+ BaseClassKind kind_; |
+ uint8_t value_bits_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(InferredValue); |
+}; |
+ |
+ |
+class DartType : public Node { |
+ public: |
+ static DartType* ReadFrom(Reader* reader); |
+ virtual void WriteTo(Writer* writer) = 0; |
+ |
+ virtual ~DartType(); |
+ |
+ DEFINE_CASTING_OPERATIONS(DartType); |
+ |
+ virtual void AcceptVisitor(Visitor* visitor); |
+ virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor) = 0; |
+ |
+ protected: |
+ DartType() { } |
+ |
+ 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_; } |
+ List<DartType>& positional_parameters() { return positional_parameters_; } |
+ List<Tuple<String, DartType> >& 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<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_; } |
+ List<Library>& libraries() { return libraries_; } |
+ Procedure* main_method() { return main_method_; } |
+ |
+ private: |
+ Program() {} |
+ |
+ List<Library> libraries_; |
+ Ref<Procedure> main_method_; |
+ StringTable string_table_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(Program); |
+}; |
+ |
+ |
+class Reference : public AllStatic { |
+ public: |
+ static Member* ReadMemberFrom(Reader* reader, bool allow_null = false); |
+ static void WriteMemberTo(Writer* writer, Member* member, |
+ 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); |
+ } |
+ 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 VisitBlockExpression(BlockExpression* node) { |
+ VisitDefaultExpression(node); |
+ } |
+}; |
+ |
+ |
+class StatementVisitor { |
+ public: |
+ virtual ~StatementVisitor() {} |
+ |
+ virtual void VisitDefaultStatement(Statement* node) = 0; |
+ virtual void VisitInvalidStatement(InvalidStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitExpressionStatement(ExpressionStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitBlock(Block* node) { VisitDefaultStatement(node); } |
+ virtual void VisitEmptyStatement(EmptyStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitAssertStatement(AssertStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitLabeledStatement(LabeledStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitBreakStatement(BreakStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitWhileStatement(WhileStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitDoStatement(DoStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitForStatement(ForStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitForInStatement(ForInStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitSwitchStatement(SwitchStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitContinueSwitchStatement(ContinueSwitchStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitIfStatement(IfStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitReturnStatement(ReturnStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitTryCatch(TryCatch* node) { VisitDefaultStatement(node); } |
+ virtual void VisitTryFinally(TryFinally* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitYieldStatement(YieldStatement* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitVariableDeclaration(VariableDeclaration* node) { |
+ VisitDefaultStatement(node); |
+ } |
+ virtual void VisitFunctionDeclaration(FunctionDeclaration* node) { |
+ VisitDefaultStatement(node); |
+ } |
+}; |
+ |
+ |
+class MemberVisitor { |
+ public: |
+ virtual ~MemberVisitor() {} |
+ |
+ virtual void VisitDefaultMember(Member* node) = 0; |
+ virtual void VisitConstructor(Constructor* node) { VisitDefaultMember(node); } |
+ virtual void VisitProcedure(Procedure* node) { VisitDefaultMember(node); } |
+ virtual void VisitField(Field* node) { VisitDefaultMember(node); } |
+}; |
+ |
+ |
+class ClassVisitor { |
+ public: |
+ virtual ~ClassVisitor() {} |
+ |
+ virtual void VisitDefaultClass(Class* node) = 0; |
+ virtual void VisitNormalClass(NormalClass* node) { VisitDefaultClass(node); } |
+ virtual void VisitMixinClass(MixinClass* node) { VisitDefaultClass(node); } |
+}; |
+ |
+ |
+class InitializerVisitor { |
+ public: |
+ virtual ~InitializerVisitor() {} |
+ |
+ virtual void VisitDefaultInitializer(Initializer* node) = 0; |
+ virtual void VisitInvalidInitializer(InvalidInitializer* node) { |
+ VisitDefaultInitializer(node); |
+ } |
+ virtual void VisitFieldInitializer(FieldInitializer* node) { |
+ VisitDefaultInitializer(node); |
+ } |
+ virtual void VisitSuperInitializer(SuperInitializer* node) { |
+ VisitDefaultInitializer(node); |
+ } |
+ virtual void VisitRedirectingInitializer(RedirectingInitializer* node) { |
+ VisitDefaultInitializer(node); |
+ } |
+ virtual void VisitLocalInitializer(LocalInitializer* node) { |
+ VisitDefaultInitializer(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 VisitInterfaceType(InterfaceType* node) { |
+ VisitDefaultDartType(node); |
+ } |
+ virtual void VisitFunctionType(FunctionType* node) { |
+ VisitDefaultDartType(node); |
+ } |
+ virtual void VisitTypeParameterType(TypeParameterType* node) { |
+ VisitDefaultDartType(node); |
+ } |
+}; |
+ |
+ |
+class ClassReferenceVisitor { |
+ public: |
+ virtual ~ClassReferenceVisitor() {} |
+ |
+ virtual void VisitDefaultClassReference(Class* node) = 0; |
+ virtual void VisitNormalClassReference(NormalClass* node) { |
+ VisitDefaultClassReference(node); |
+ } |
+ virtual void VisitMixinClassReference(MixinClass* node) { |
+ VisitDefaultClassReference(node); |
+ } |
+}; |
+ |
+ |
+class MemberReferenceVisitor { |
+ public: |
+ virtual ~MemberReferenceVisitor() {} |
+ |
+ virtual void VisitDefaultMemberReference(Member* node) = 0; |
+ virtual void VisitFieldReference(Field* node) { |
+ VisitDefaultMemberReference(node); |
+ } |
+ virtual void VisitConstructorReference(Constructor* node) { |
+ VisitDefaultMemberReference(node); |
+ } |
+ virtual void VisitProcedureReference(Procedure* node) { |
+ VisitDefaultMemberReference(node); |
+ } |
+}; |
+ |
+ |
+class TreeVisitor : public ExpressionVisitor, |
+ public StatementVisitor, |
+ public MemberVisitor, |
+ public ClassVisitor, |
+ public InitializerVisitor { |
+ public: |
+ virtual ~TreeVisitor() {} |
+ |
+ virtual void VisitDefaultTreeNode(TreeNode* node) = 0; |
+ virtual void VisitDefaultStatement(Statement* node) { |
+ VisitDefaultTreeNode(node); |
+ } |
+ virtual void VisitDefaultExpression(Expression* node) { |
+ VisitDefaultTreeNode(node); |
+ } |
+ virtual void VisitDefaultMember(Member* node) { VisitDefaultTreeNode(node); } |
+ virtual void VisitDefaultClass(Class* node) { VisitDefaultTreeNode(node); } |
+ virtual void VisitDefaultInitializer(Initializer* node) { |
+ VisitDefaultTreeNode(node); |
+ } |
+ |
+ virtual void VisitLibrary(Library* node) { VisitDefaultTreeNode(node); } |
+ virtual void VisitTypeParameter(TypeParameter* node) { |
+ VisitDefaultTreeNode(node); |
+ } |
+ virtual void VisitFunctionNode(FunctionNode* node) { |
+ 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); } |
+}; |
+ |
+ |
+class Visitor : public TreeVisitor, |
+ public DartTypeVisitor, |
+ public ClassReferenceVisitor, |
+ public MemberReferenceVisitor { |
+ public: |
+ virtual ~Visitor() {} |
+ |
+ virtual void VisitDefaultNode(Node* node) = 0; |
+ virtual void VisitInferredValue(InferredValue* node) { |
+ VisitDefaultNode(node); |
+ } |
+ virtual void VisitDefaultTreeNode(TreeNode* node) { VisitDefaultNode(node); } |
+ virtual void VisitDefaultDartType(DartType* node) { VisitDefaultNode(node); } |
+ virtual void VisitName(Name* node) { VisitDefaultNode(node); } |
+ virtual void VisitDefaultClassReference(Class* node) { |
+ VisitDefaultNode(node); |
+ } |
+ virtual void VisitDefaultMemberReference(Member* node) { |
+ VisitDefaultNode(node); |
+ } |
+}; |
+ |
+ |
+class RecursiveVisitor : public Visitor { |
+ public: |
+ virtual ~RecursiveVisitor() {} |
+ |
+ virtual void VisitDefaultNode(Node* node) { node->VisitChildren(this); } |
+ |
+ virtual void VisitDefaultClassReference(Class* node) {} |
+ virtual void VisitDefaultMemberReference(Member* node) {} |
+}; |
+ |
+ |
+template <typename T> |
+List<T>::~List() { |
+ for (int i = 0; i < length_; i++) { |
+ delete array_[i]; |
+ } |
+ delete[] array_; |
+} |
+ |
+ |
+template <typename T> |
+void List<T>::EnsureInitialized(int length) { |
+ if (length < length_) return; |
+ |
+ T** old_array = array_; |
+ int old_length = length_; |
+ |
+ // TODO(27590) Maybe we should use double-growth instead to avoid running |
+ // into the quadratic case. |
+ length_ = length; |
+ array_ = new T*[length_]; |
+ |
+ // Move old elements at the start (if necessary). |
+ int offset = 0; |
+ if (old_array != NULL) { |
+ for (; offset < old_length; offset++) { |
+ array_[offset] = old_array[offset]; |
+ } |
+ } |
+ |
+ // Set the rest to NULL. |
+ for (; offset < length_; offset++) { |
+ array_[offset] = NULL; |
+ } |
+ |
+ delete[] old_array; |
+} |
+ |
+ |
+template <typename T> |
+template <typename IT> |
+IT* List<T>::GetOrCreate(int index) { |
+ EnsureInitialized(index + 1); |
+ |
+ T* member = array_[index]; |
+ if (member == NULL) { |
+ member = array_[index] = new IT(); |
+ } |
+ return IT::Cast(member); |
+} |
+ |
+ |
+template <typename T> |
+template <typename IT, typename PT> |
+IT* List<T>::GetOrCreate(int index, PT* parent) { |
+ EnsureInitialized(index + 1); |
+ |
+ T* member = array_[index]; |
+ if (member == NULL) { |
+ member = array_[index] = new IT(); |
+ member->parent_ = parent; |
+ } else { |
+ ASSERT(member->parent_ == parent); |
+ } |
+ return IT::Cast(member); |
+} |
+ |
+} // 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 // VM_KERNEL_H_ |