D-Scanner/std/d/ast.d

// Written in the D programming language.

/**
 * This module defines an Abstract Syntax Tree for the D language
 *
 * Examples:
 * ---
 * // TODO
 * ---
 *
 * Copyright: Brian Schott 2013
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt Boost, License 1.0)
 * Authors: Brian Schott
 * Source: $(PHOBOSSRC std/d/_ast.d)
 */

module std.d.ast;

import std.d.lexer;

/**
 * Implements the $(LINK2 http://en.wikipedia.org/wiki/Visitor_pattern, Visitor Pattern)
 * for the various AST classes
 */
abstract class ASTVisitor
{
	/** */ void visit(AddExpression addExpression) {}
	/** */ void visit(AliasDeclaration aliasDeclaration) {}
	/** */ void visit(AliasInitializer aliasInitializer) {}
	/** */ void visit(AliasThisDeclaration aliasThisDeclaration) {}
	/** */ void visit(AlignAttribute alignAttribute) {}
	/** */ void visit(AndAndExpression andAndExpression) {}
	/** */ void visit(AndExpression andExpression) {}
	/** */ void visit(ArgumentList argumentList) {}
	/** */ void visit(Arguments arguments) {}
	/** */ void visit(ArrayInitializer arrayInitializer) {}
	/** */ void visit(ArrayLiteral arrayLiteral) {}
	/** */ void visit(ArrayMemberInitialization arrayMemberInitialization) {}
	/** */ void visit(ArrayMemberInitializations arrayMemberInitializations) {}
	/** */ void visit(AsmAddExp asmAddExp) {}
	/** */ void visit(AsmAndExp asmAndExp) {}
	/** */ void visit(AsmBrExp asmBrExp) {}
	/** */ void visit(AsmEqualExp asmEqualExp) {}
	/** */ void visit(AsmExp asmExp) {}
	/** */ void visit(AsmInstruction asmInstruction) {}
	/** */ void visit(AsmLogAndExp asmLogAndExp) {}
	/** */ void visit(AsmLogOrExp asmLogOrExp) {}
	/** */ void visit(AsmMulExp asmMulExp) {}
	/** */ void visit(AsmOrExp asmOrExp) {}
	/** */ void visit(AsmPrimaryExp asmPrimaryExp) {}
	/** */ void visit(AsmRelExp asmRelExp) {}
	/** */ void visit(AsmShiftExp asmShiftExp) {}
	/** */ void visit(AsmStatement asmStatement) {}
	/** */ void visit(AsmTypePrefix asmTypePrefix) {}
	/** */ void visit(AsmUnaExp asmUnaExp) {}
	/** */ void visit(AsmXorExp asmXorExp) {}
	/** */ void visit(AssertExpression assertExpression) {}
	/** */ void visit(AssertStatement assertStatement) {}
	/** */ void visit(AssignExpression assignExpression) {}
	/** */ void visit(AssignStatement assignStatement) {}
	/** */ void visit(AssocArrayLiteral assocArrayLiteral) {}
	/** */ void visit(AtAttribute atAttribute) {}
	/** */ void visit(Attribute attribute) {}
	/** */ void visit(AttributedDeclaration attributedDeclaration) {}
	/** */ void visit(AutoDeclaration autoDeclaration) {}
	/** */ void visit(BlockStatement blockStatement) {}
	/** */ void visit(BodyStatement bodyStatement) {}
	/** */ void visit(BreakStatement breakStatement) {}
	/** */ void visit(BasicType builtinType) {}
	/** */ void visit(CaseRangeStatement caseRangeStatement) {}
	/** */ void visit(CaseStatement caseStatement) {}
	/** */ void visit(CastExpression castExpression) {}
	/** */ void visit(CastQualifier castQualifier) {}
	/** */ void visit(Catch catch_) {}
	/** */ void visit(Catches catches) {}
	/** */ void visit(ClassBody classBody) {}
	/** */ void visit(ClassDeclaration classDeclaration) {}
	/** */ void visit(CmpExpression cmpExpression) {}
	/** */ void visit(CompileCondition compileCondition) {}
	/** */ void visit(ConditionalDeclaration conditionalDeclaration) {}
	/** */ void visit(ConditionalStatement conditionalStatement) {}
	/** */ void visit(Constraint constraint) {}
	/** */ void visit(Constructor constructor) {}
	/** */ void visit(ContinueStatement continueStatement) {}
	/** */ void visit(DebugCondition debugCondition) {}
	/** */ void visit(DebugSpecification debugSpecification) {}
	/** */ void visit(Declaration declaration) {}
	/** */ void visit(DeclarationsAndStatements declarationsAndStatements) {}
	/** */ void visit(Declarator declarator) {}
	/** */ void visit(DeclaratorSuffix declaratorSuffix) {}
	/** */ void visit(DefaultStatement defaultStatement) {}
	/** */ void visit(DeleteExpression deleteExpression) {}
	/** */ void visit(DeleteStatement deleteStatement) {}
	/** */ void visit(Deprecated deprecated_) {}
	/** */ void visit(Destructor destructor) {}
	/** */ void visit(DoStatement doStatement) {}
	/** */ void visit(EnumBody enumBody) {}
	/** */ void visit(EnumDeclaration enumDeclaration) {}
	/** */ void visit(EnumMember enumMember) {}
	/** */ void visit(EqualExpression equalExpression) {}
	/** */ void visit(Expression expression) {}
	/** */ void visit(FinalSwitchStatement finalSwitchStatement) {}
	/** */ void visit(Finally finally_) {}
	/** */ void visit(ForStatement forStatement) {}
	/** */ void visit(ForeachRangeStatement foreachRangeStatement) {}
	/** */ void visit(ForeachStatement foreachStatement) {}
	/** */ void visit(ForeachType foreachType) {}
	/** */ void visit(ForeachTypeList foreachTypeList) {}
	/** */ void visit(FunctionAttribute functionAttribute) {}
	/** */ void visit(FunctionBody functionBody) {}
	/** */ void visit(FunctionCallExpression functionCallExpression) {}
	/** */ void visit(FunctionCallStatement functionCallStatement) {}
	/** */ void visit(FunctionDeclaration functionDeclaration) {}
	/** */ void visit(FunctionLiteralExpression functionLiteralExpression) {}
	/** */ void visit(GotoStatement gotoStatement) {}
	/** */ void visit(IdentifierChain identifierChain) {}
	/** */ void visit(IdentifierList identifierList) {}
	/** */ void visit(IdentifierOrTemplateChain identifierOrTemplateChain) {}
	/** */ void visit(IdentifierOrTemplateInstance identifierOrTemplateInstance) {}
	/** */ void visit(IdentityExpression identityExpression) {}
	/** */ void visit(IfStatement ifStatement) {}
	/** */ void visit(ImportBind importBind) {}
	/** */ void visit(ImportBindings importBindings) {}
	/** */ void visit(ImportDeclaration importDeclaration) {}
	/** */ void visit(ImportExpression importExpression) {}
	/** */ void visit(ImportList importList) {}
	/** */ void visit(InExpression inExpression) {}
	/** */ void visit(InStatement inStatement) {}
	/** */ void visit(Initialize initialize) {}
	/** */ void visit(Initializer initializer) {}
	/** */ void visit(InterfaceDeclaration interfaceDeclaration) {}
	/** */ void visit(Invariant invariant_) {}
	/** */ void visit(IsExpression isExpression) {}
	/** */ void visit(KeyValuePair keyValuePair) {}
	/** */ void visit(KeyValuePairs keyValuePairs) {}
	/** */ void visit(LabeledStatement labeledStatement) {}
	/** */ void visit(LambdaExpression lambdaExpression) {}
	/** */ void visit(LastCatch lastCatch) {}
	/** */ void visit(LinkageAttribute linkageAttribute) {}
	/** */ void visit(MemberFunctionAttribute memberFunctionAttribute) {}
	/** */ void visit(MixinDeclaration mixinDeclaration) {}
	/** */ void visit(MixinExpression mixinExpression) {}
	/** */ void visit(MixinTemplateName mixinTemplateName) {}
	/** */ void visit(Module module_) {}
	/** */ void visit(ModuleDeclaration moduleDeclaration) {}
	/** */ void visit(MulExpression mulExpression) {}
	/** */ void visit(NewAnonClassExpression newAnonClassExpression) {}
	/** */ void visit(NewExpression newExpression) {}
	/** */ void visit(NonEmptyStatement nonEmptyStatement) {}
	/** */ void visit(NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault) {}
	/** */ void visit(NonVoidInitializer nonVoidInitializer) {}
	/** */ void visit(Opcode opcode) {}
	/** */ void visit(Operand operand) {}
	/** */ void visit(Operands operands) {}
	/** */ void visit(OrExpression orExpression) {}
	/** */ void visit(OrOrExpression orOrExpression) {}
	/** */ void visit(OutStatement outStatement) {}
	/** */ void visit(Parameter parameter) {}
	/** */ void visit(ParameterAttribute parameterAttribute) {}
	/** */ void visit(Parameters parameters) {}
	/** */ void visit(PostIncDecExpression postIncDecExpression) {}
	/** */ void visit(PowExpression powExpression) {}
	/** */ void visit(PragmaDeclaration pragmaDeclaration) {}
	/** */ void visit(PragmaExpression pragmaExpression) {}
	/** */ void visit(PreIncDecExpression preIncDecExpression) {}
	/** */ void visit(PrimaryExpression primaryExpression) {}
	/** */ void visit(ProtectionAttribute protectionAttribute) {}
	/** */ void visit(Register register) {}
	/** */ void visit(RelExpression relExpression) {}
	/** */ void visit(ReturnStatement returnStatement) {}
	/** */ void visit(ScopeGuardStatement scopeGuardStatement) {}
	/** */ void visit(SharedStaticConstructor sharedStaticConstructor) {}
	/** */ void visit(SharedStaticDestructor sharedStaticDestructor) {}
	/** */ void visit(ShiftExpression shiftExpression) {}
	/** */ void visit(SingleImport singleImport) {}
	/** */ void visit(Statement statement) {}
	/** */ void visit(StatementNoCaseNoDefault statementNoCaseNoDefault) {}
	/** */ void visit(StaticAssertDeclaration staticAssertDeclaration) {}
	/** */ void visit(StaticAssertStatement staticAssertStatement) {}
	/** */ void visit(StaticConstructor staticConstructor) {}
	/** */ void visit(StaticDestructor staticDestructor) {}
	/** */ void visit(StaticIfCondition staticIfCondition) {}
	/** */ void visit(StorageClass storageClass) {}
	/** */ void visit(StructBody structBody) {}
	/** */ void visit(StructDeclaration structDeclaration) {}
	/** */ void visit(StructInitializer structInitializer) {}
	/** */ void visit(StructMemberInitializer structMemberInitializer) {}
	/** */ void visit(StructMemberInitializers structMemberInitializers) {}
	/** */ void visit(SwitchBody switchBody) {}
	/** */ void visit(SwitchStatement switchStatement) {}
	/** */ void visit(Symbol symbol) {}
	/** */ void visit(SynchronizedStatement synchronizedStatement) {}
	/** */ void visit(TemplateAliasParameter templateAliasParameter) {}
	/** */ void visit(TemplateArgument templateArgument) {}
	/** */ void visit(TemplateArgumentList templateArgumentList) {}
	/** */ void visit(TemplateArguments templateArguments) {}
	/** */ void visit(TemplateDeclaration templateDeclaration) {}
	/** */ void visit(TemplateInstance templateInstance) {}
	/** */ void visit(TemplateMixinStatement templateMixinStatement) {}
	/** */ void visit(TemplateParameter templateParameter) {}
	/** */ void visit(TemplateParameterList templateParameterList) {}
	/** */ void visit(TemplateParameters templateParameters) {}
	/** */ void visit(TemplateSingleArgument templateSingleArgument) {}
	/** */ void visit(TemplateThisParameter templateThisParameter) {}
	/** */ void visit(TemplateTupleParameter templateTupleParameter) {}
	/** */ void visit(TemplateTypeParameter templateTypeParameter) {}
	/** */ void visit(TemplateValueParameter templateValueParameter) {}
	/** */ void visit(TemplateValueParameterDefault templateValueParameterDefault) {}
	/** */ void visit(TernaryExpression ternaryExpression) {}
	/** */ void visit(ThrowStatement throwStatement) {}
	/** */ void visit(TraitsArgument traitsArgument) {}
	/** */ void visit(TraitsExpression traitsExpression) {}
	/** */ void visit(TryStatement tryStatement) {}
	/** */ void visit(Type type) {}
	/** */ void visit(Type2 type2) {}
	/** */ void visit(Type3 type3) {}
	/** */ void visit(TypeConstructor typeConstructor) {}
	/** */ void visit(TypeConstructors typeConstructors) {}
	/** */ void visit(TypeSpecialization typeSpecialization) {}
	/** */ void visit(TypeSuffix typeSuffix) {}
	/** */ void visit(TypeidExpression typeidExpression) {}
	/** */ void visit(TypeofExpression typeofExpression) {}
	/** */ void visit(UnaryExpression unaryExpression) {}
	/** */ void visit(UnionDeclaration unionDeclaration) {}
	/** */ void visit(Unittest unittest_) {}
	/** */ void visit(VariableDeclaration variableDeclaration) {}
	/** */ void visit(VersionCondition versionCondition) {}
	/** */ void visit(VersionSpecification versionSpecification) {}
	/** */ void visit(WhileStatement whileStatement) {}
	/** */ void visit(WithStatement withStatement) {}
	/** */ void visit(XorExpression xorExpression) {}
}

interface ASTNode
{
	void accept(ASTVisitor visitor);
}

immutable string OVERRIDE_DEFAULT_ACCEPT = q{override void accept(ASTVisitor visitor) { visitor.visit(this); }};
immutable string DEFAULT_ACCEPT = q{void accept(ASTVisitor visitor) { visitor.visit(this); }};


immutable string SHIFT_SHIFT_BODY = q{
	Token operator;
	ShiftExpression left;
	ShiftExpression right;
};

class AddExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TokenType operator;
	AddExpression left;
	MulExpression right;
}

class AliasDeclaration : Declaration
{
public:
	mixin(OVERRIDE_DEFAULT_ACCEPT);
	Type type;
	Declarator declarator;
	AliasInitializer[] initializations;
}

class AliasInitializer : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	Type type;
}

class AliasThisDeclaration : Declaration
{
public:
	mixin(OVERRIDE_DEFAULT_ACCEPT);
	Token identifier;
}

class AlignAttribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token intLiteral;
}

class AndAndExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AndAndExpression left;
	OrExpression right;
}

class AndExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AndExpression andExpression;
	ShiftExpression shiftExpression;
}

class ArgumentList : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression[] arguments;
}

class Arguments : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ArgumentList argumentList;
}

class ArrayInitializer : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ArrayMemberInitializations arrayMemberInitializations;
}

class ArrayLiteral : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ArgumentList argumentList;
}

class ArrayMemberInitialization : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
	NonVoidInitializer nonVoidInitializer;
}

class ArrayMemberInitializations : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ArrayMemberInitialization[] arrayMemberInitializations;
}

class AsmAddExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token operator;
	AsmMulExp left;
	AsmMulExp right;
}

class AsmAndExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmEqualExp left;
	AsmEqualExp right;
}

class AsmBrExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmBrExp asmBrExp;
	AsmEqualExp asmEqualExp;
	AsmUnaExp asmUnaExp;
}

class AsmEqualExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmRelExp left;
	AsmRelExp right;
	Token operator;
}

class AsmExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmLogOrExp left;
	AsmExp middle;
	AsmExp right;
}

class AsmInstruction : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifierOrInteger;
	bool hasAlign;
	AsmExp asmExp;
	Opcode opcode;
	Operands operands;
}

class AsmLogAndExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmOrExp left;
	AsmOrExp right;
}

class AsmLogOrExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmLogAndExp left;
	AsmLogAndExp right;
}

class AsmMulExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmBrExp left;
	AsmBrExp right;
	Token operator;
}

class AsmOrExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmXorExp left;
	AsmXorExp right;
}

class AsmPrimaryExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	IdentifierChain identifierChain;
	Register register;
	Token token;
}

class AsmRelExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmShiftExp left;
	AsmShiftExp right;
	Token operator;
}

class AsmShiftExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmAddExp left;
	AsmAddExp right;
	Token operator;
}

class AsmStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmInstruction[] asmInstructions;
}

class AsmTypePrefix : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token left;
	Token right;
}

class AsmUnaExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmTypePrefix asmTypePrefix;
	AsmExp asmExp;
	Token prefix;
	AsmPrimaryExp asmPrimaryExp;
	AsmUnaExp asmUnaExp;
}

class AsmXorExp : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmAndExp left;
	AsmAndExp right;
}

class AssertExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assertion;
	AssignExpression message;
}

class AssertStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssertExpression assertExpression;
}

class AssignExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TernaryExpression ternaryExpression;
	AssignExpression assignExpression;
	Token operator;
}

class AssignStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	PreIncDecExpression preIncDecExpression;
	PostIncDecExpression postIncDecExpression;
	UnaryExpression[] unaryExpressions;
	AssignExpression[] assignExpressions;
	Token[] assignOperators;
}

class AssocArrayLiteral : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	KeyValuePairs keyValuePairs;
}

class AtAttribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionCallExpression functionCallExpression;
	ArgumentList argumentList;
	Token identifier;
}

class AttributedDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Declaration[] declarations;
}

class Attribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	LinkageAttribute linkageAttribute;
	AlignAttribute alignAttribute;
	PragmaExpression pragmaExpression;
	Deprecated deprecated_;
	ProtectionAttribute protectionAttribute;
	AtAttribute atAttribute;
	Token attribute;
}

class AutoDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	StorageClass storageClass;
	Token[] identifiers;
	Initializer[] initializers;
}

class BlockStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	DeclarationsAndStatements declarationsAndStatements;
}

class BodyStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	DeclarationsAndStatements declarationsAndStatements;
}

class BreakStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	bool hasIdentifier;
}

class BasicType : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TokenType type;
}

class CaseRangeStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression low;
	AssignExpression high;
	DeclarationsAndStatements declarationsAndStatements;
}

class CaseStatement: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ArgumentList argumentList;
	DeclarationsAndStatements declarationsAndStatements;
}

class CastExpression: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	CastQualifier castQualifier;
}

class CastQualifier: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TokenType first;
	TokenType second;
	bool hasSecond;
}

class Catches: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Catch[] catches;
	LastCatch lastCatch;
}

class Catch: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	Token identifier;
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class ClassBody: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Declaration[] declarations;
	Invariant[] invariants;
}

class ClassDeclaration: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token name;
	TemplateParameters templateParameters;
	Constraint constraint;
	IdentifierList superClasses;
	ClassBody classBody;
}

class CmpExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ShiftExpression shiftExpression;
	EqualExpression equalExpression;
	IdentityExpression identityExpression;
	RelExpression relExpression;
	InExpression inExpression;
}

class CompileCondition : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	VersionCondition versionCondition;
	DebugCondition debugCondition;
	StaticIfCondition staticIfCondition;
}

class ConditionalDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	CompileCondition compileCondition;
	Declaration[] trueDeclarations;
	Declaration[] falseDeclarations;
}

class ConditionalStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	CompileCondition compileCondition;
	NonEmptyStatementNoCaseNoDefault trueStatement;
	NonEmptyStatementNoCaseNoDefault falseStatement;
}

class Constraint : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
}

class Constructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Parameters parameters;
	FunctionBody functionBody;
}

class ContinueStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	bool hasIdentifier;
	Token identifier;
}

class DebugCondition : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifierOrInteger;
	bool hasIdentifierOrInteger;
}

class DebugSpecification : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifierOrInteger;
}

class Declaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AttributedDeclaration attributedDeclaration;
	ImportDeclaration importDeclaration;
	FunctionDeclaration functionDeclaration;
	VariableDeclaration variableDeclaration;
	AliasThisDeclaration aliasThisDeclaration;
	StructDeclaration structDeclaration;
	ClassDeclaration classDeclaration;
	InterfaceDeclaration interfaceDeclaration;
	UnionDeclaration unionDeclaration;
	EnumDeclaration enumDeclaration;
	AliasDeclaration aliasDeclaration;
	MixinDeclaration mixinDeclaration;
	Unittest unittest_;
	StaticAssertDeclaration staticAssertDeclaration;
	TemplateDeclaration templateDeclaration;
	Constructor constructor;
	Destructor destructor;
	StaticConstructor staticConstructor;
	StaticDestructor staticDestructor;
	SharedStaticDestructor sharedStaticDestructor;
	SharedStaticConstructor sharedStaticConstructor;
	ConditionalDeclaration conditionalDeclaration;
	PragmaDeclaration pragmaDeclaration;
}

class DeclarationsAndStatements : ASTNode
{
	mixin(DEFAULT_ACCEPT);
	ASTNode[] declarationsAndStatements;
}

class Declarator : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	DeclaratorSuffix declaratiorSuffix;
	Initializer initializer;
}

class DeclaratorSuffix : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	AssignExpression assignExpression;
}

class DefaultStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	DeclarationsAndStatements declarationsAndStatements;
}

class DeleteExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	UnaryExpression unaryExpression;
}

class DeleteStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	DeleteExpression deleteExpression;
}

class Deprecated : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
}

class Destructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionBody functionBody;
}

class DoStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	BlockStatement blockStatement;
	Expression expression;
}

class EnumBody : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	EnumMember[] enumMembers;
}

class EnumDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	Type type;
	EnumBody enumBody;
}

class EnumMember : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	Type type;
	AssignExpression assignExpression;
}

class EqualExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	mixin(SHIFT_SHIFT_BODY);
}

class Expression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression[] assignExpressions;
}

class FinalSwitchStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	SwitchStatement switchStatement;
}

class Finally : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class ForStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Declaration initializationDeclaration;
	Statement initializationStatement;
	Expression test;
	Expression increment;
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class ForeachRangeStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ForeachType foreachType;
	Expression lower;
	Expression higher;
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class ForeachStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token foreachType;
	ForeachTypeList foreachTypeList;
	Expression expression;
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class ForeachType : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	bool isRef;
	Type type;
	Token identifier;
}

class ForeachTypeList : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ForeachType[] foreachTypes;
}

class FunctionAttribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token pureOrNothrow;
	AtAttribute atAttribute;
}

class FunctionBody : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	BlockStatement blockStatement;
	BodyStatement bodyStatement;
	OutStatement outStatement;
	InStatement inStatement;
}

class FunctionCallExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	UnaryExpression unaryExpression;
	TemplateArguments templateArguments;
	Arguments arguments;
}

class FunctionCallStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionCallExpression functionCallExpression;
}

class FunctionDeclaration : Declaration
{
public:
	mixin(OVERRIDE_DEFAULT_ACCEPT);
	Type returnType;
	Token name;
	TemplateParameters templateParameters;
	Parameters parameters;
	Constraint constraint;
	FunctionBody functionBody;
}

class FunctionLiteralExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token functionOrDelegate;
	Type type;
	Parameters parameters;
	FunctionAttribute[] functionAttributes;
	FunctionBody functionBody;
}

class GotoStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	Token identifier;
	bool isDefault;
}

class IdentifierChain : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token[] identifiers;
}

class IdentifierList : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token[] identifiers;
}

class IdentifierOrTemplateChain : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	IdentifierOrTemplateInstance[] identifiers;
}

class IdentifierOrTemplateInstance : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateInstance templateInstance;
}

class IdentityExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	mixin(SHIFT_SHIFT_BODY);
}

class IfStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	NonEmptyStatementNoCaseNoDefault thenStatement;
	NonEmptyStatementNoCaseNoDefault elseStatement;
}

class ImportBind : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token left;
	Token right;
}

class ImportBindings : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	SingleImport bind;
	ImportBind[] ImportBinds;
}

class ImportDeclaration : Declaration
{
public:
	mixin(OVERRIDE_DEFAULT_ACCEPT);
	bool isStatic;
	ImportList importList;
}

class ImportExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
}

class ImportList : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	SingleImport singleImport;
	ImportList next;
	ImportBindings bindings;
}

class InExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	mixin(SHIFT_SHIFT_BODY);
}

class InStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	BlockStatement blockStatement;
}

class Initialize : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class Initializer : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonVoidInitializer nonVoidInitializer;
}

class InterfaceDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateParameters templateParameters;
	Constraint constraint;
	IdentifierList identifierList;
	StructBody structBody;
}

class Invariant : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	BlockStatement blockStatement;
}

class IsExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	AssignExpression assignExpression;
	Token identifier;
	TypeSpecialization typeSpecialization;
	TemplateParameterList templateParameterList;
	Token equalsOrColon;
}

class KeyValuePair : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	KeyValuePair[] keyValuePairs;
}

class KeyValuePairs : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression key;
	AssignExpression value;
}

class LabeledStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
    Token identifier;
	Statement statement;
}

class LambdaExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	Parameters paramaters;
	FunctionAttribute[] functionAttributes;
	AssignExpression assignExpression;
}

class LastCatch : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class LinkageAttribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	bool hasPlusPlus;
}

class MemberFunctionAttribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token token;
	FunctionAttribute functionAttribute;
}

class MixinDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	MixinExpression mixinExpression;
}

class MixinExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
}

class MixinTemplateName : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	bool hasDot;
	IdentifierOrTemplateChain identifierOrTemplateChain;
	TypeofExpression typeofExpression;
}

class Module : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ModuleDeclaration moduleDeclaration;
	Declaration[] declarations;
}

class ModuleDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	IdentifierChain moduleName;
}


class MulExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token operator;
	UnaryExpression left;
	UnaryExpression right;
}

class NewAnonClassExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Arguments allocatorArguments;
	Arguments constructorArguments;
	IdentifierList identifierList;
	ClassBody classBody;

}

class NewExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	NewAnonClassExpression newAnonClassExpression;
	Arguments arguments;
	AssignExpression assignExpression;
}

class NonEmptyStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
	CaseStatement caseStatement;
	CaseRangeStatement caseRangeStatement;
	DefaultStatement defaultStatement;
}

class NonEmptyStatementNoCaseNoDefault : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	LabeledStatement labeledStatement;
	BlockStatement blockStatement;
	AssignStatement assignStatement;
	IfStatement ifStatement;
	WhileStatement whileStatement;
	DoStatement doStatement;
	ForStatement forStatement;
	ForeachStatement foreachStatement;
	SwitchStatement switchStatement;
	FinalSwitchStatement finalSwitchStatement;
	ContinueStatement continueStatement;
	BreakStatement breakStatement;
	ReturnStatement returnStatement;
	GotoStatement gotoStatement;
	WithStatement withStatement;
	SynchronizedStatement synchronizedStatement;
	TryStatement tryStatement;
	ThrowStatement throwStatement;
	ScopeGuardStatement scopeGuardStatement;
	AsmStatement asmStatement;
	ForeachRangeStatement foreachRangeStatement;
	ConditionalStatement conditionalStatement;
	StaticAssertStatement staticAssertStatement;
	AssertStatement assertStatement;
	TemplateMixinStatement templateMixinStatement;
	VersionSpecification versionSpecification;
	DebugSpecification debugSpecification;
	FunctionCallStatement functionCallStatement;
	DeleteStatement deleteStatement;
}

class NonVoidInitializer : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
	ArrayInitializer arrayInitializer;
	StructInitializer structInitializer;

}

class Opcode : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
}

class Operand : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AsmExp asmExp;
}

class Operands : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Operand[] operands;
}

class OrExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	XorExpression xorExpression;
	OrExpression orExpression;
}

class OrOrExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	OrOrExpression orOrExpression;
	AndAndExpression andAndExpression;
}

class OutStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token parameter;
	BlockStatement blockStatement;
}

class Parameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	ParameterAttribute[] paramaterAttributes;
	Type type;
	Token name;
	bool vararg;
}

class ParameterAttribute: ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token attribute;
	TypeConstructor typeConstructor;
}

class Parameters : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Parameter[] paramaters;
	bool hasVarargs;
}

class PostIncDecExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token operator;
	UnaryExpression unaryExpression;
}

class PowExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	UnaryExpression unaryExpression;
	PowExpression powExpression;
}

class PragmaDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	PragmaExpression pragmaExpression;
}

class PragmaExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	ArgumentList argumentList;
}

class PreIncDecExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token operator;
	UnaryExpression unaryExpression;
}

class PrimaryExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token primary;
	bool hasDot;
    IdentifierOrTemplateInstance identifierOrTemplateInstance;
    Type type;
    TypeofExpression typeofExpression;
    TypeidExpression typeidExpression;
    ArrayLiteral arrayLiteral;
    AssocArrayLiteral assocArrayLiteral;
    Expression expression;
    IsExpression isExpression;
    LambdaExpression lambdaExpression;
    FunctionLiteralExpression functionLiteralExpression;
    TraitsExpression traitsExpression;
    MixinExpression mixinExpression;
    ImportExpression importExpression;
}

class ProtectionAttribute : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token attribute;
}

class Register : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	Token integerLiteral;
	bool hasIntegerLiteral;
}

class RelExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	mixin(SHIFT_SHIFT_BODY);
}

class ReturnStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
}

class ScopeGuardStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class SharedStaticConstructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionBody functionBody;
}

class SharedStaticDestructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionBody functionBody;
}

class ShiftExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AddExpression addExpression;
	ShiftExpression shiftExpression;
	Token operator;
}

class SingleImport : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token rename;
	IdentifierChain import_;
}

class Statement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatement nonEmptyStatement;
}

class StatementNoCaseNoDefault : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class StaticAssertDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	StaticAssertStatement staticAssertStatement;
}

class StaticAssertStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssertStatement assertStatement;
}

class StaticConstructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionBody functionBody;
}

class StaticDestructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	FunctionBody functionBody;
}

class StaticIfCondition : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
}

class StorageClass : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AtAttribute atAttribute;
	TypeConstructor typeConstructor;
	Token storageClass;
}

class StructBody : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Declaration[] declarations;
}

class StructDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateParameters templateParameters;
	Constraint constraint;
	StructBody structBody;
}

class StructInitializer : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	StructMemberInitializers structMemberInitializers;

}

class StructMemberInitializer : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	bool hasIdentifier;
	NonVoidInitializer nonVoidInitializer;
}

class StructMemberInitializers : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	StructMemberInitializer[] structMemberInitializers;
}

class SwitchBody : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Statement[] statements;
}

class SwitchStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	SwitchBody switchBody;
}

class Symbol : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	IdentifierOrTemplateChain identifierOrTemplateChain;
	bool hasDot;
}

class SynchronizedStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}

class TemplateAliasParameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	Token identifier;
	Type colonType;
	Expression colonExpression;
	Type assignType;
	Expression assignExpression;
}

class TemplateArgument : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	AssignExpression assignExpression;
	Symbol symbol;
}

class TemplateArgumentList : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TemplateArgument[] templateArguments;
}

class TemplateArguments : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TemplateArgumentList templateArgumentList;
	TemplateSingleArgument templateSingleArgument;
}

class TemplateDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateParameters templateParameters;
	Constraint constraint;
	Declaration[] declarations;
}

class TemplateInstance : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateArguments templateArguments;
}

class TemplateMixinStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateArguments templateArguments;
	MixinTemplateName mixinTemplateName;
}

class TemplateParameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TemplateTypeParameter templateTypeParameter;
	TemplateValueParameter templateValueParameter;
	TemplateAliasParameter templateAliasParameter;
	TemplateTupleParameter templateTupleParameter;
	TemplateThisParameter templateThisParameter;
}

class TemplateParameterList : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TemplateParameter[] templateParameters;
}

class TemplateParameters : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TemplateParameterList templateParameterList;
}

class TemplateSingleArgument : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token token;
	BasicType builtinType;
}

class TemplateThisParameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TemplateTypeParameter templateTypeParameter;
}

class TemplateTupleParameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
}

class TemplateTypeParameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	Type colonType;
	Type assignType;
}

class TemplateValueParameter : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	Token identifier;
	Expression expression;
	TemplateValueParameterDefault templateValueParameterDefault;
}

class TemplateValueParameterDefault : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
	Token token;
}

class TernaryExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	OrOrExpression orOrExpression;
	Expression expression;
	TernaryExpression ternaryExpression;
}

class ThrowStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
}

class TraitsArgument : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	AssignExpression assignExpression;
	Type type;
}

class TraitsExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TraitsArgument[] traitsArguments;
}

class TryStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
	Catches catches;
	Finally finally_;
}

class Type : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TypeConstructors typeConstructors;
	Type2 type2;
}

class Type2 : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type2 type2;
	Type3 type3;
	TypeSuffix typeSuffix;
}

class Type3 : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	BasicType builtinType;
	Symbol symbol;
	TypeofExpression typeofExpression;
	IdentifierOrTemplateChain identifierOrTemplateChain;
	TypeConstructor typeConstructor;
	Type type;
}

class TypeConstructor : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token typeConstructor;
}

class TypeConstructors : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	TypeConstructor[] typeConstructors;
}

class TypeSpecialization : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token token;
	Type type;
}

class TypeSuffix : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token delegateOrFunction;
	bool star;
	Type type;
	AssignExpression assignExpression;
	MemberFunctionAttribute[] memberFunctionAttributes;
}

class TypeidExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Type type;
	Expression expression;
}

class TypeofExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	Token return_;
}

class UnaryExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	PrimaryExpression primaryExpression;
	UnaryExpression unaryExpression;
	Token prefix;
	PreIncDecExpression preIncDecExpression;
	PostIncDecExpression postIncDecExpression;
	NewExpression newExpression;
	DeleteExpression deleteExpression;
	CastExpression castExpression;
	FunctionCallExpression functionCallExpression;
	ArgumentList argumentList;
	AssignExpression low;
	AssignExpression high;
	IdentifierOrTemplateInstance identifierOrTemplateInstance;
	AssertExpression assertExpression;
}

class UnionDeclaration : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token identifier;
	TemplateParameters templateParameters;
	Constraint constraint;
	StructBody structBody;
}

class Unittest : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	BlockStatement blockStatement;
}

class VariableDeclaration : Declaration
{
public:
	mixin(OVERRIDE_DEFAULT_ACCEPT);
	Type type;
	Declarator[] declarators;
	StorageClass storageClass;
	AutoDeclaration autoDeclaration;
}

class VersionCondition : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token token;
}

class VersionSpecification : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Token token;
}

class WhileStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	StatementNoCaseNoDefault statementNoCaseNoDefault;
}

class WithStatement : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	Expression expression;
	Symbol symbol;
	TemplateInstance templateInstance;
}

class XorExpression : ASTNode
{
public:
	mixin(DEFAULT_ACCEPT);
	XorExpression left;
	AndExpression right;
}