Index: runtime/vm/kernel.cc |
diff --git a/runtime/vm/kernel.cc b/runtime/vm/kernel.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..340b60d409e382513eacaef3d7c2e537736069c9 |
--- /dev/null |
+++ b/runtime/vm/kernel.cc |
@@ -0,0 +1,1205 @@ |
+// 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. |
+ |
+#include "vm/kernel.h" |
+ |
+namespace dart { |
+ |
+namespace kernel { |
+ |
+ |
+template <typename T> |
+void VisitList(List<T>* list, Visitor* visitor) { |
+ for (int i = 0; i < list->length(); ++i) { |
+ (*list)[i]->AcceptVisitor(visitor); |
+ } |
+} |
+ |
+ |
+Node::~Node() {} |
+ |
+ |
+TreeNode::~TreeNode() {} |
+ |
+ |
+void TreeNode::AcceptVisitor(Visitor* visitor) { AcceptTreeVisitor(visitor); } |
+ |
+ |
+Library::~Library() {} |
+ |
+ |
+void Library::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitLibrary(this); |
+} |
+ |
+ |
+void Library::VisitChildren(Visitor* visitor) { |
+ VisitList(&classes(), visitor); |
+ VisitList(&procedures(), visitor); |
+ VisitList(&fields(), visitor); |
+} |
+ |
+ |
+Class::~Class() {} |
+ |
+ |
+void Class::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ AcceptClassVisitor(visitor); |
+} |
+ |
+ |
+NormalClass::~NormalClass() {} |
+ |
+ |
+void NormalClass::AcceptClassVisitor(ClassVisitor* visitor) { |
+ visitor->VisitNormalClass(this); |
+} |
+ |
+ |
+void NormalClass::AcceptReferenceVisitor(ClassReferenceVisitor* visitor) { |
+ visitor->VisitNormalClassReference(this); |
+} |
+ |
+ |
+void NormalClass::VisitChildren(Visitor* visitor) { |
+ VisitList(&type_parameters(), visitor); |
+ if (super_class() != NULL) visitor->VisitInterfaceType(super_class()); |
+ VisitList(&implemented_classes(), visitor); |
+ VisitList(&constructors(), visitor); |
+ VisitList(&procedures(), visitor); |
+ VisitList(&fields(), visitor); |
+} |
+ |
+ |
+MixinClass::~MixinClass() {} |
+ |
+ |
+void MixinClass::AcceptClassVisitor(ClassVisitor* visitor) { |
+ visitor->VisitMixinClass(this); |
+} |
+ |
+ |
+void MixinClass::AcceptReferenceVisitor(ClassReferenceVisitor* visitor) { |
+ visitor->VisitMixinClassReference(this); |
+} |
+ |
+ |
+void MixinClass::VisitChildren(Visitor* visitor) { |
+ VisitList(&type_parameters(), visitor); |
+ visitor->VisitInterfaceType(first()); |
+ visitor->VisitInterfaceType(second()); |
+ VisitList(&implemented_classes(), visitor); |
+ VisitList(&constructors(), visitor); |
+} |
+ |
+ |
+Member::~Member() {} |
+ |
+ |
+void Member::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ AcceptMemberVisitor(visitor); |
+} |
+ |
+ |
+Field::~Field() {} |
+ |
+ |
+void Field::AcceptMemberVisitor(MemberVisitor* visitor) { |
+ visitor->VisitField(this); |
+} |
+ |
+ |
+void Field::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) { |
+ visitor->VisitFieldReference(this); |
+} |
+ |
+ |
+void Field::VisitChildren(Visitor* visitor) { |
+ type()->AcceptDartTypeVisitor(visitor); |
+ visitor->VisitName(name()); |
+ if (initializer() != NULL) initializer()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+Constructor::~Constructor() {} |
+ |
+ |
+void Constructor::AcceptMemberVisitor(MemberVisitor* visitor) { |
+ visitor->VisitConstructor(this); |
+} |
+ |
+ |
+void Constructor::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) { |
+ visitor->VisitConstructorReference(this); |
+} |
+ |
+ |
+void Constructor::VisitChildren(Visitor* visitor) { |
+ visitor->VisitName(name()); |
+ visitor->VisitFunctionNode(function()); |
+ VisitList(&initializers(), visitor); |
+} |
+ |
+ |
+Procedure::~Procedure() {} |
+ |
+ |
+void Procedure::AcceptMemberVisitor(MemberVisitor* visitor) { |
+ visitor->VisitProcedure(this); |
+} |
+ |
+ |
+void Procedure::AcceptReferenceVisitor(MemberReferenceVisitor* visitor) { |
+ visitor->VisitProcedureReference(this); |
+} |
+ |
+ |
+void Procedure::VisitChildren(Visitor* visitor) { |
+ visitor->VisitName(name()); |
+ if (function() != NULL) visitor->VisitFunctionNode(function()); |
+} |
+ |
+ |
+Initializer::~Initializer() {} |
+ |
+ |
+void Initializer::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ AcceptInitializerVisitor(visitor); |
+} |
+ |
+ |
+InvalidInitializer::~InvalidInitializer() {} |
+ |
+ |
+void InvalidInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) { |
+ visitor->VisitInvalidInitializer(this); |
+} |
+ |
+ |
+void InvalidInitializer::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+FieldInitializer::~FieldInitializer() {} |
+ |
+ |
+void FieldInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) { |
+ visitor->VisitFieldInitializer(this); |
+} |
+ |
+ |
+void FieldInitializer::VisitChildren(Visitor* visitor) { |
+ visitor->VisitFieldReference(field()); |
+ value()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+SuperInitializer::~SuperInitializer() {} |
+ |
+ |
+void SuperInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) { |
+ visitor->VisitSuperInitializer(this); |
+} |
+ |
+ |
+void SuperInitializer::VisitChildren(Visitor* visitor) { |
+ visitor->VisitConstructorReference(target()); |
+ visitor->VisitArguments(arguments()); |
+} |
+ |
+ |
+RedirectingInitializer::~RedirectingInitializer() {} |
+ |
+ |
+void RedirectingInitializer::AcceptInitializerVisitor( |
+ InitializerVisitor* visitor) { |
+ visitor->VisitRedirectingInitializer(this); |
+} |
+ |
+ |
+void RedirectingInitializer::VisitChildren(Visitor* visitor) { |
+ visitor->VisitConstructorReference(target()); |
+ visitor->VisitArguments(arguments()); |
+} |
+ |
+ |
+LocalInitializer::~LocalInitializer() {} |
+ |
+ |
+void LocalInitializer::AcceptInitializerVisitor(InitializerVisitor* visitor) { |
+ visitor->VisitLocalInitializer(this); |
+} |
+ |
+ |
+void LocalInitializer::VisitChildren(Visitor* visitor) { |
+ visitor->VisitVariableDeclaration(variable()); |
+} |
+ |
+ |
+FunctionNode::~FunctionNode() {} |
+ |
+ |
+void FunctionNode::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitFunctionNode(this); |
+} |
+ |
+ |
+void FunctionNode::VisitChildren(Visitor* visitor) { |
+ VisitList(&type_parameters(), visitor); |
+ VisitList(&positional_parameters(), visitor); |
+ VisitList(&named_parameters(), visitor); |
+ if (return_type() != NULL) return_type()->AcceptDartTypeVisitor(visitor); |
+ if (body() != NULL) body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+Expression::~Expression() {} |
+ |
+ |
+void Expression::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+InvalidExpression::~InvalidExpression() {} |
+ |
+ |
+void InvalidExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitInvalidExpression(this); |
+} |
+ |
+ |
+void InvalidExpression::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+VariableGet::~VariableGet() {} |
+ |
+ |
+void VariableGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitVariableGet(this); |
+} |
+ |
+ |
+void VariableGet::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+VariableSet::~VariableSet() {} |
+ |
+ |
+void VariableSet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitVariableSet(this); |
+} |
+ |
+ |
+void VariableSet::VisitChildren(Visitor* visitor) { |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+PropertyGet::~PropertyGet() {} |
+ |
+ |
+void PropertyGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitPropertyGet(this); |
+} |
+ |
+ |
+void PropertyGet::VisitChildren(Visitor* visitor) { |
+ receiver()->AcceptExpressionVisitor(visitor); |
+ visitor->VisitName(name()); |
+} |
+ |
+ |
+PropertySet::~PropertySet() {} |
+ |
+ |
+void PropertySet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitPropertySet(this); |
+} |
+ |
+ |
+void PropertySet::VisitChildren(Visitor* visitor) { |
+ receiver()->AcceptExpressionVisitor(visitor); |
+ visitor->VisitName(name()); |
+ value()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+DirectPropertyGet::~DirectPropertyGet() {} |
+ |
+ |
+void DirectPropertyGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitDirectPropertyGet(this); |
+} |
+ |
+ |
+void DirectPropertyGet::VisitChildren(Visitor* visitor) { |
+ receiver()->AcceptExpressionVisitor(visitor); |
+ target()->AcceptReferenceVisitor(visitor); |
+} |
+ |
+ |
+DirectPropertySet::~DirectPropertySet() {} |
+ |
+ |
+void DirectPropertySet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitDirectPropertySet(this); |
+} |
+ |
+ |
+void DirectPropertySet::VisitChildren(Visitor* visitor) { |
+ receiver()->AcceptExpressionVisitor(visitor); |
+ target()->AcceptReferenceVisitor(visitor); |
+ value()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+StaticGet::~StaticGet() {} |
+ |
+ |
+void StaticGet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitStaticGet(this); |
+} |
+ |
+ |
+void StaticGet::VisitChildren(Visitor* visitor) { |
+ target()->AcceptReferenceVisitor(visitor); |
+} |
+ |
+ |
+StaticSet::~StaticSet() {} |
+ |
+ |
+void StaticSet::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitStaticSet(this); |
+} |
+ |
+ |
+void StaticSet::VisitChildren(Visitor* visitor) { |
+ target()->AcceptReferenceVisitor(visitor); |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+Arguments::~Arguments() {} |
+ |
+ |
+void Arguments::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitArguments(this); |
+} |
+ |
+ |
+void Arguments::VisitChildren(Visitor* visitor) { |
+ VisitList(&types(), visitor); |
+ VisitList(&positional(), visitor); |
+ VisitList(&named(), visitor); |
+} |
+ |
+ |
+NamedExpression::~NamedExpression() {} |
+ |
+ |
+void NamedExpression::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitNamedExpression(this); |
+} |
+ |
+ |
+void NamedExpression::VisitChildren(Visitor* visitor) { |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+MethodInvocation::~MethodInvocation() {} |
+ |
+ |
+void MethodInvocation::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitMethodInvocation(this); |
+} |
+ |
+ |
+void MethodInvocation::VisitChildren(Visitor* visitor) { |
+ receiver()->AcceptExpressionVisitor(visitor); |
+ visitor->VisitName(name()); |
+ visitor->VisitArguments(arguments()); |
+} |
+ |
+ |
+DirectMethodInvocation::~DirectMethodInvocation() {} |
+ |
+ |
+void DirectMethodInvocation::AcceptExpressionVisitor( |
+ ExpressionVisitor* visitor) { |
+ visitor->VisitDirectMethodInvocation(this); |
+} |
+ |
+ |
+void DirectMethodInvocation::VisitChildren(Visitor* visitor) { |
+ receiver()->AcceptExpressionVisitor(visitor); |
+ visitor->VisitProcedureReference(target()); |
+ visitor->VisitArguments(arguments()); |
+} |
+ |
+ |
+StaticInvocation::~StaticInvocation() {} |
+ |
+ |
+void StaticInvocation::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitStaticInvocation(this); |
+} |
+ |
+ |
+void StaticInvocation::VisitChildren(Visitor* visitor) { |
+ visitor->VisitProcedureReference(procedure()); |
+ visitor->VisitArguments(arguments()); |
+} |
+ |
+ |
+ConstructorInvocation::~ConstructorInvocation() {} |
+ |
+ |
+void ConstructorInvocation::AcceptExpressionVisitor( |
+ ExpressionVisitor* visitor) { |
+ visitor->VisitConstructorInvocation(this); |
+} |
+ |
+ |
+void ConstructorInvocation::VisitChildren(Visitor* visitor) { |
+ visitor->VisitConstructorReference(target()); |
+ visitor->VisitArguments(arguments()); |
+} |
+ |
+ |
+Not::~Not() {} |
+ |
+ |
+void Not::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitNot(this); |
+} |
+ |
+ |
+void Not::VisitChildren(Visitor* visitor) { |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+LogicalExpression::~LogicalExpression() {} |
+ |
+ |
+void LogicalExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitLogicalExpression(this); |
+} |
+ |
+ |
+void LogicalExpression::VisitChildren(Visitor* visitor) { |
+ left()->AcceptExpressionVisitor(visitor); |
+ right()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+ConditionalExpression::~ConditionalExpression() {} |
+ |
+ |
+void ConditionalExpression::AcceptExpressionVisitor( |
+ ExpressionVisitor* visitor) { |
+ visitor->VisitConditionalExpression(this); |
+} |
+ |
+ |
+void ConditionalExpression::VisitChildren(Visitor* visitor) { |
+ condition()->AcceptExpressionVisitor(visitor); |
+ then()->AcceptExpressionVisitor(visitor); |
+ otherwise()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+StringConcatenation::~StringConcatenation() {} |
+ |
+ |
+void StringConcatenation::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitStringConcatenation(this); |
+} |
+ |
+ |
+void StringConcatenation::VisitChildren(Visitor* visitor) { |
+ VisitList(&expressions(), visitor); |
+} |
+ |
+ |
+IsExpression::~IsExpression() {} |
+ |
+ |
+void IsExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitIsExpression(this); |
+} |
+ |
+ |
+void IsExpression::VisitChildren(Visitor* visitor) { |
+ operand()->AcceptExpressionVisitor(visitor); |
+ type()->AcceptDartTypeVisitor(visitor); |
+} |
+ |
+ |
+AsExpression::~AsExpression() {} |
+ |
+ |
+void AsExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitAsExpression(this); |
+} |
+ |
+ |
+void AsExpression::VisitChildren(Visitor* visitor) { |
+ operand()->AcceptExpressionVisitor(visitor); |
+ type()->AcceptDartTypeVisitor(visitor); |
+} |
+ |
+ |
+BasicLiteral::~BasicLiteral() {} |
+ |
+ |
+void BasicLiteral::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+StringLiteral::~StringLiteral() {} |
+ |
+ |
+void StringLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitStringLiteral(this); |
+} |
+ |
+ |
+BigintLiteral::~BigintLiteral() {} |
+ |
+ |
+void BigintLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitBigintLiteral(this); |
+} |
+ |
+ |
+IntLiteral::~IntLiteral() {} |
+ |
+ |
+void IntLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitIntLiteral(this); |
+} |
+ |
+ |
+DoubleLiteral::~DoubleLiteral() {} |
+ |
+ |
+void DoubleLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitDoubleLiteral(this); |
+} |
+ |
+ |
+BoolLiteral::~BoolLiteral() {} |
+ |
+ |
+void BoolLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitBoolLiteral(this); |
+} |
+ |
+ |
+NullLiteral::~NullLiteral() {} |
+ |
+ |
+void NullLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitNullLiteral(this); |
+} |
+ |
+ |
+SymbolLiteral::~SymbolLiteral() {} |
+ |
+ |
+void SymbolLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitSymbolLiteral(this); |
+} |
+ |
+ |
+void SymbolLiteral::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+TypeLiteral::~TypeLiteral() {} |
+ |
+ |
+void TypeLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitTypeLiteral(this); |
+} |
+ |
+ |
+void TypeLiteral::VisitChildren(Visitor* visitor) { |
+ type()->AcceptDartTypeVisitor(visitor); |
+} |
+ |
+ |
+ThisExpression::~ThisExpression() {} |
+ |
+ |
+void ThisExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitThisExpression(this); |
+} |
+ |
+ |
+void ThisExpression::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+Rethrow::~Rethrow() {} |
+ |
+ |
+void Rethrow::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitRethrow(this); |
+} |
+ |
+ |
+void Rethrow::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+Throw::~Throw() {} |
+ |
+ |
+void Throw::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitThrow(this); |
+} |
+ |
+ |
+void Throw::VisitChildren(Visitor* visitor) { |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+ListLiteral::~ListLiteral() {} |
+ |
+ |
+void ListLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitListLiteral(this); |
+} |
+ |
+ |
+void ListLiteral::VisitChildren(Visitor* visitor) { |
+ type()->AcceptDartTypeVisitor(visitor); |
+ VisitList(&expressions(), visitor); |
+} |
+ |
+ |
+MapLiteral::~MapLiteral() {} |
+ |
+ |
+void MapLiteral::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitMapLiteral(this); |
+} |
+ |
+ |
+void MapLiteral::VisitChildren(Visitor* visitor) { |
+ key_type()->AcceptDartTypeVisitor(visitor); |
+ value_type()->AcceptDartTypeVisitor(visitor); |
+ VisitList(&entries(), visitor); |
+} |
+ |
+ |
+MapEntry::~MapEntry() {} |
+ |
+ |
+void MapEntry::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitMapEntry(this); |
+} |
+ |
+ |
+void MapEntry::VisitChildren(Visitor* visitor) { |
+ key()->AcceptExpressionVisitor(visitor); |
+ value()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+AwaitExpression::~AwaitExpression() {} |
+ |
+ |
+void AwaitExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitAwaitExpression(this); |
+} |
+ |
+ |
+void AwaitExpression::VisitChildren(Visitor* visitor) { |
+ operand()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+FunctionExpression::~FunctionExpression() {} |
+ |
+ |
+void FunctionExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitFunctionExpression(this); |
+} |
+ |
+ |
+void FunctionExpression::VisitChildren(Visitor* visitor) { |
+ visitor->VisitFunctionNode(function()); |
+} |
+ |
+ |
+Let::~Let() {} |
+ |
+ |
+void Let::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitLet(this); |
+} |
+ |
+ |
+void Let::VisitChildren(Visitor* visitor) { |
+ visitor->VisitVariableDeclaration(variable()); |
+ body()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+BlockExpression::~BlockExpression() {} |
+ |
+ |
+void BlockExpression::AcceptExpressionVisitor(ExpressionVisitor* visitor) { |
+ visitor->VisitBlockExpression(this); |
+} |
+ |
+ |
+void BlockExpression::VisitChildren(Visitor* visitor) { |
+ visitor->VisitBlock(body()); |
+ value()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+Statement::~Statement() {} |
+ |
+ |
+void Statement::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+InvalidStatement::~InvalidStatement() {} |
+ |
+ |
+void InvalidStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitInvalidStatement(this); |
+} |
+ |
+ |
+void InvalidStatement::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+ExpressionStatement::~ExpressionStatement() {} |
+ |
+ |
+void ExpressionStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitExpressionStatement(this); |
+} |
+ |
+ |
+void ExpressionStatement::VisitChildren(Visitor* visitor) { |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+Block::~Block() {} |
+ |
+ |
+void Block::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitBlock(this); |
+} |
+ |
+ |
+void Block::VisitChildren(Visitor* visitor) { |
+ VisitList(&statements(), visitor); |
+} |
+ |
+ |
+EmptyStatement::~EmptyStatement() {} |
+ |
+ |
+void EmptyStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitEmptyStatement(this); |
+} |
+ |
+ |
+void EmptyStatement::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+AssertStatement::~AssertStatement() {} |
+ |
+ |
+void AssertStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitAssertStatement(this); |
+} |
+ |
+ |
+void AssertStatement::VisitChildren(Visitor* visitor) { |
+ condition()->AcceptExpressionVisitor(visitor); |
+ if (message() != NULL) message()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+LabeledStatement::~LabeledStatement() {} |
+ |
+ |
+void LabeledStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitLabeledStatement(this); |
+} |
+ |
+ |
+void LabeledStatement::VisitChildren(Visitor* visitor) { |
+ body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+BreakStatement::~BreakStatement() {} |
+ |
+ |
+void BreakStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitBreakStatement(this); |
+} |
+ |
+ |
+void BreakStatement::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+WhileStatement::~WhileStatement() {} |
+ |
+ |
+void WhileStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitWhileStatement(this); |
+} |
+ |
+ |
+void WhileStatement::VisitChildren(Visitor* visitor) { |
+ condition()->AcceptExpressionVisitor(visitor); |
+ body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+DoStatement::~DoStatement() {} |
+ |
+ |
+void DoStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitDoStatement(this); |
+} |
+ |
+ |
+void DoStatement::VisitChildren(Visitor* visitor) { |
+ body()->AcceptStatementVisitor(visitor); |
+ condition()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+ForStatement::~ForStatement() {} |
+ |
+ |
+void ForStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitForStatement(this); |
+} |
+ |
+ |
+void ForStatement::VisitChildren(Visitor* visitor) { |
+ VisitList(&variables(), visitor); |
+ if (condition() != NULL) condition()->AcceptExpressionVisitor(visitor); |
+ VisitList(&updates(), visitor); |
+ body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+ForInStatement::~ForInStatement() {} |
+ |
+ |
+void ForInStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitForInStatement(this); |
+} |
+ |
+ |
+void ForInStatement::VisitChildren(Visitor* visitor) { |
+ visitor->VisitVariableDeclaration(variable()); |
+ iterable()->AcceptExpressionVisitor(visitor); |
+ body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+SwitchStatement::~SwitchStatement() {} |
+ |
+ |
+void SwitchStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitSwitchStatement(this); |
+} |
+ |
+ |
+void SwitchStatement::VisitChildren(Visitor* visitor) { |
+ condition()->AcceptExpressionVisitor(visitor); |
+ VisitList(&cases(), visitor); |
+} |
+ |
+ |
+SwitchCase::~SwitchCase() {} |
+ |
+ |
+void SwitchCase::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitSwitchCase(this); |
+} |
+ |
+ |
+void SwitchCase::VisitChildren(Visitor* visitor) { |
+ VisitList(&expressions(), visitor); |
+ body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+ContinueSwitchStatement::~ContinueSwitchStatement() {} |
+ |
+ |
+void ContinueSwitchStatement::AcceptStatementVisitor( |
+ StatementVisitor* visitor) { |
+ visitor->VisitContinueSwitchStatement(this); |
+} |
+ |
+ |
+void ContinueSwitchStatement::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+IfStatement::~IfStatement() {} |
+ |
+ |
+void IfStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitIfStatement(this); |
+} |
+ |
+ |
+void IfStatement::VisitChildren(Visitor* visitor) { |
+ condition()->AcceptExpressionVisitor(visitor); |
+ then()->AcceptStatementVisitor(visitor); |
+ otherwise()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+ReturnStatement::~ReturnStatement() {} |
+ |
+ |
+void ReturnStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitReturnStatement(this); |
+} |
+ |
+ |
+void ReturnStatement::VisitChildren(Visitor* visitor) { |
+ if (expression() != NULL) expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+TryCatch::~TryCatch() {} |
+ |
+ |
+void TryCatch::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitTryCatch(this); |
+} |
+ |
+ |
+void TryCatch::VisitChildren(Visitor* visitor) { |
+ body()->AcceptStatementVisitor(visitor); |
+ VisitList(&catches(), visitor); |
+} |
+ |
+ |
+Catch::~Catch() {} |
+ |
+ |
+void Catch::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitCatch(this); |
+} |
+ |
+ |
+void Catch::VisitChildren(Visitor* visitor) { |
+ if (guard() != NULL) guard()->AcceptDartTypeVisitor(visitor); |
+ if (exception() != NULL) visitor->VisitVariableDeclaration(exception()); |
+ if (stack_trace() != NULL) visitor->VisitVariableDeclaration(stack_trace()); |
+ body()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+TryFinally::~TryFinally() {} |
+ |
+ |
+void TryFinally::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitTryFinally(this); |
+} |
+ |
+ |
+void TryFinally::VisitChildren(Visitor* visitor) { |
+ body()->AcceptStatementVisitor(visitor); |
+ finalizer()->AcceptStatementVisitor(visitor); |
+} |
+ |
+ |
+YieldStatement::~YieldStatement() {} |
+ |
+ |
+void YieldStatement::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitYieldStatement(this); |
+} |
+ |
+ |
+void YieldStatement::VisitChildren(Visitor* visitor) { |
+ expression()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+VariableDeclaration::~VariableDeclaration() {} |
+ |
+ |
+void VariableDeclaration::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitVariableDeclaration(this); |
+} |
+ |
+ |
+void VariableDeclaration::VisitChildren(Visitor* visitor) { |
+ if (type() != NULL) type()->AcceptDartTypeVisitor(visitor); |
+ if (initializer() != NULL) initializer()->AcceptExpressionVisitor(visitor); |
+} |
+ |
+ |
+FunctionDeclaration::~FunctionDeclaration() {} |
+ |
+ |
+void FunctionDeclaration::AcceptStatementVisitor(StatementVisitor* visitor) { |
+ visitor->VisitFunctionDeclaration(this); |
+} |
+ |
+ |
+void FunctionDeclaration::VisitChildren(Visitor* visitor) { |
+ visitor->VisitVariableDeclaration(variable()); |
+ visitor->VisitFunctionNode(function()); |
+} |
+ |
+ |
+Name::~Name() {} |
+ |
+ |
+void Name::AcceptVisitor(Visitor* visitor) { visitor->VisitName(this); } |
+ |
+ |
+void Name::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+InferredValue::~InferredValue() {} |
+ |
+ |
+void InferredValue::AcceptVisitor(Visitor* visitor) { |
+ visitor->VisitInferredValue(this); |
+} |
+ |
+ |
+void InferredValue::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+DartType::~DartType() {} |
+ |
+ |
+void DartType::AcceptVisitor(Visitor* visitor) { |
+ AcceptDartTypeVisitor(visitor); |
+} |
+ |
+ |
+InvalidType::~InvalidType() {} |
+ |
+ |
+void InvalidType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) { |
+ visitor->VisitInvalidType(this); |
+} |
+ |
+ |
+void InvalidType::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+DynamicType::~DynamicType() {} |
+ |
+ |
+void DynamicType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) { |
+ visitor->VisitDynamicType(this); |
+} |
+ |
+ |
+void DynamicType::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+VoidType::~VoidType() {} |
+ |
+ |
+void VoidType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) { |
+ visitor->VisitVoidType(this); |
+} |
+ |
+ |
+void VoidType::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+InterfaceType::~InterfaceType() {} |
+ |
+ |
+void InterfaceType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) { |
+ visitor->VisitInterfaceType(this); |
+} |
+ |
+ |
+void InterfaceType::VisitChildren(Visitor* visitor) { |
+ klass()->AcceptReferenceVisitor(visitor); |
+ VisitList(&type_arguments(), visitor); |
+} |
+ |
+ |
+FunctionType::~FunctionType() {} |
+ |
+ |
+void FunctionType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) { |
+ visitor->VisitFunctionType(this); |
+} |
+ |
+ |
+void FunctionType::VisitChildren(Visitor* visitor) { |
+ VisitList(&type_parameters(), visitor); |
+ VisitList(&positional_parameters(), visitor); |
+ for (int i = 0; i < named_parameters().length(); ++i) { |
+ named_parameters()[i]->second()->AcceptDartTypeVisitor(visitor); |
+ } |
+ return_type()->AcceptDartTypeVisitor(visitor); |
+} |
+ |
+ |
+TypeParameterType::~TypeParameterType() {} |
+ |
+ |
+void TypeParameterType::AcceptDartTypeVisitor(DartTypeVisitor* visitor) { |
+ visitor->VisitTypeParameterType(this); |
+} |
+ |
+ |
+void TypeParameterType::VisitChildren(Visitor* visitor) {} |
+ |
+ |
+TypeParameter::~TypeParameter() {} |
+ |
+ |
+void TypeParameter::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitTypeParameter(this); |
+} |
+ |
+ |
+void TypeParameter::VisitChildren(Visitor* visitor) { |
+ bound()->AcceptDartTypeVisitor(visitor); |
+} |
+ |
+ |
+Program::~Program() {} |
+ |
+ |
+void Program::AcceptTreeVisitor(TreeVisitor* visitor) { |
+ visitor->VisitProgram(this); |
+} |
+ |
+ |
+void Program::VisitChildren(Visitor* visitor) { |
+ VisitList(&libraries(), visitor); |
+ visitor->VisitProcedureReference(main_method()); |
+} |
+ |
+ |
+} // namespace kernel |
+ |
+} // namespace dart |