// 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;

// TODO: Many of these classes can be simplified by using std.variant.Algebraic

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

interface ASTNode
{
    /** */ void accept(ASTVisitor visitor);
}

immutable string DEFAULT_ACCEPT = q{void accept(ASTVisitor visitor) {}};

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 : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Type type;
    /** */ Declarator declarator;
    /** */ AliasInitializer[] initializers;
}

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

///
class AliasThisDeclaration : ASTNode
{
public:
    mixin(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 left;
    /** */ CmpExpression right;
}

///
class ArgumentList : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ AssignExpression[] items;
}

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

///
class ArrayInitializer : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ ArrayMemberInitialization[] arrayMemberInitializations;
}

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

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

///
class AsmAddExp : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType operator;
    /** */ AsmAddExp 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 identifierOrIntegerOrOpcode;
    /** */ bool hasAlign;
    /** */ AsmExp asmExp;
    /** */ 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);
    /** */ TokenType operator;
    /** */ AsmMulExp left;
    /** */ AsmBrExp right;

}

///
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 AssignExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TernaryExpression ternaryExpression;
    /** */ AssignExpression assignExpression;
    /** */ TokenType operator;
}

///
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:
    override void accept(ASTVisitor visitor)
    {
        if (attribute !is null)
            visitor.visit(attribute);
		if (declaration !is null)
			visitor.visit(declaration);
    }
    /** */ Attribute attribute;
    /** */ Declaration declaration;
}

///
class Attribute : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ LinkageAttribute linkageAttribute;
    /** */ AlignAttribute alignAttribute;
    /** */ PragmaExpression pragmaExpression;
    /** */ Deprecated deprecated_;
    /** */ AtAttribute atAttribute;
    /** */ TokenType 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);
    /** */ BlockStatement blockStatement;
}

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

///
class BaseClass : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
    /** */ TypeofExpression typeofExpression;
}

///
class BaseClassList : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ BaseClass[] items;
}

///
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;
    /** */ UnaryExpression unaryExpression;
}

///
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;
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

///
class ClassBody: ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ DeclarationOrInvariant[] declarationOrInvariants;
}

///
class ClassDeclaration: ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token name;
    /** */ TemplateParameters templateParameters;
    /** */ Constraint constraint;
    /** */ BaseClassList baseClassList;
    /** */ 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;
    /** */ StatementNoCaseNoDefault trueStatement;
    /** */ StatementNoCaseNoDefault falseStatement;
}

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

///
class Constructor : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Parameters parameters;
    /** */ FunctionBody functionBody;
    /** */ Constraint constraint;
    /** */ MemberFunctionAttribute[] memberFunctionAttributes;
    /** */ TemplateParameters templateParameters;
}

///
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:

    override void accept(ASTVisitor visitor)
    {
        if (attributedDeclaration !is null) visitor.visit(attributedDeclaration);
        if (importDeclaration !is null) visitor.visit(importDeclaration);
        if (functionDeclaration !is null) visitor.visit(functionDeclaration);
        if (variableDeclaration !is null) visitor.visit(variableDeclaration);
        if (aliasThisDeclaration !is null) visitor.visit(aliasThisDeclaration);
        if (structDeclaration !is null) visitor.visit(structDeclaration);
        if (classDeclaration !is null) visitor.visit(classDeclaration);
        if (interfaceDeclaration !is null) visitor.visit(interfaceDeclaration);
        if (unionDeclaration !is null) visitor.visit(unionDeclaration);
        if (enumDeclaration !is null) visitor.visit(enumDeclaration);
        if (aliasDeclaration !is null) visitor.visit(aliasDeclaration);
        if (mixinDeclaration !is null) visitor.visit(mixinDeclaration);
        if (unittest_ !is null) visitor.visit(unittest_);
        if (staticAssertDeclaration !is null) visitor.visit(staticAssertDeclaration);
        if (templateDeclaration !is null) visitor.visit(templateDeclaration);
        if (constructor !is null) visitor.visit(constructor);
        if (destructor !is null) visitor.visit(destructor);
        if (staticConstructor !is null) visitor.visit(staticConstructor);
        if (staticDestructor !is null) visitor.visit(staticDestructor);
        if (sharedStaticDestructor !is null) visitor.visit(sharedStaticDestructor);
        if (sharedStaticConstructor !is null) visitor.visit(sharedStaticConstructor);
        if (conditionalDeclaration !is null) visitor.visit(conditionalDeclaration);
        if (pragmaDeclaration !is null) visitor.visit(pragmaDeclaration);
        if (versionSpecification !is null) visitor.visit(versionSpecification);
    }

    /** */ 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;
    /** */ VersionSpecification versionSpecification;
	/** */ Declaration[] declarations;
}

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

///
class DeclarationOrInvariant : ASTNode
{
    mixin(DEFAULT_ACCEPT);
    /** */ Declaration declaration;
    /** */ Invariant invariant_;
}

///
class DeclarationOrStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Declaration declaration;
    /** */ StatementNoCaseNoDefault statement;
}

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

///
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);
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
    /** */ 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);
    /** */ TokenType operator;
    /** */ ShiftExpression left;
    /** */ ShiftExpression right;
}

///
class Expression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ AssignExpression[] items;
}

///
class ExpressionStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Expression expression;
}

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

///
class Finally : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

///
class ForStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ DeclarationOrStatement declarationOrStatement;
    /** */ Expression test;
    /** */ Expression increment;
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

///
class ForeachStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType foreachType;
    /** */ ForeachTypeList foreachTypeList;
    /** */ Expression low;
    /** */ Expression high;
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

///
class ForeachType : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType[] typeConstructors;
    /** */ Type type;
    /** */ Token identifier;
}

///
class ForeachTypeList : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ ForeachType[] items;
}

///
class FunctionAttribute : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token token;
    /** */ 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 : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ bool hasAuto;
    /** */ bool hasRef;
    /** */ Type returnType;
    /** */ Token name;
    /** */ TemplateParameters templateParameters;
    /** */ Parameters parameters;
    /** */ Constraint constraint;
    /** */ FunctionBody functionBody;
    /** */ MemberFunctionAttribute[] memberFunctionAttributes;
}

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

///
class GotoStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Expression expression;
    /** */ Token token;
}

///
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[] identifierOrTemplateInstances;
}

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

///
class IdentityExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ bool negated;
    /** */ ShiftExpression left;
    /** */ ShiftExpression right;
}

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

///
class ImportBind : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token left;
    /** */ Token right;
    /** */ bool hasRight;
}

///
class ImportBindings : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ SingleImport singleImport;
    /** */ ImportBind[] importBinds;
}

///
class ImportDeclaration : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ SingleImport[] singleImports;
    /** */ ImportBindings importBindings;
}

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

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

///
class IndexExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ UnaryExpression unaryExpression;
    /** */ ArgumentList argumentList;
}

///
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);
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

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

///
class InterfaceDeclaration : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token identifier;
    /** */ TemplateParameters templateParameters;
    /** */ Constraint constraint;
    /** */ BaseClassList baseClassList;
    /** */ 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;
    /** */ TokenType equalsOrColon;
}

///
class KeyValuePair : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ AssignExpression key;
    /** */ AssignExpression value;
}

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

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

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

///
class LastCatch : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

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

///
class MemberFunctionAttribute : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType tokenType;
    /** */ AtAttribute atAttribute;
}

///
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:
    override void accept(ASTVisitor visitor)
    {
        if (moduleDeclaration !is null)
            visitor.visit(moduleDeclaration);
        foreach(d; declarations)
            visitor.visit(d);
    }
    /** */ ModuleDeclaration moduleDeclaration;
    /** */ Declaration[] declarations;
}

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


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

///
class NewAnonClassExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Arguments allocatorArguments;
    /** */ Arguments constructorArguments;
    /** */ BaseClassList baseClassList;
    /** */ ClassBody classBody;
}

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


///
class StatementNoCaseNoDefault : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ LabeledStatement labeledStatement;
    /** */ BlockStatement blockStatement;
    /** */ 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;
    /** */ ConditionalStatement conditionalStatement;
    /** */ StaticAssertStatement staticAssertStatement;
    /** */ TemplateMixinStatement templateMixinStatement;
    /** */ VersionSpecification versionSpecification;
    /** */ DebugSpecification debugSpecification;
    /** */ FunctionCallStatement functionCallStatement;
    /** */ ExpressionStatement expressionStatement;
}

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

}

///
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);
    /** */ OrExpression left;
    /** */ XorExpression right;
}

///
class OrOrExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ OrOrExpression left;
    /** */ AndAndExpression right;
}

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

///
class Parameter : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType[] parameterAttributes;
    /** */ Type type;
    /** */ Token name;
    /** */ bool vararg;
    /** */ AssignExpression default_;
}

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

///
class Postblit : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ FunctionBody functionBody;
}

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

///
class PowExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ PowExpression left;
    /** */ UnaryExpression right;
}

///
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;
    /** */ IdentifierOrTemplateInstance identifierOrTemplateInstance;
    /** */ TokenType basicType;
    /** */ TypeofExpression typeofExpression;
    /** */ TypeidExpression typeidExpression;
    /** */ ArrayLiteral arrayLiteral;
    /** */ AssocArrayLiteral assocArrayLiteral;
    /** */ Expression expression;
    /** */ IsExpression isExpression;
    /** */ LambdaExpression lambdaExpression;
    /** */ FunctionLiteralExpression functionLiteralExpression;
    /** */ TraitsExpression traitsExpression;
    /** */ MixinExpression mixinExpression;
    /** */ ImportExpression importExpression;
    /** */ Vector vector;
}

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

///
class RelExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType operator;
    /** */ RelExpression left;
    /** */ ShiftExpression right;
}

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

///
class ScopeGuardStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token identifier;
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

///
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);
    /** */ TokenType operator;
    /** */ ShiftExpression left;
    /** */ AddExpression right;
}

///
class SingleImport : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token identifier;
    /** */ IdentifierChain identifierChain;
}

///
class SliceExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ UnaryExpression unaryExpression;
    /** */ AssignExpression lower;
    /** */ AssignExpression upper;
}

///
class Statement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
    /** */ CaseStatement caseStatement;
    /** */ CaseRangeStatement caseRangeStatement;
    /** */ DefaultStatement defaultStatement;
}

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

///
class StaticAssertStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ AssertExpression assertExpression;
}

///
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;
    /** */ Token token;
}

///
class StructBody : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ StructBodyItem[] structBodyItems;
}

class StructBodyItem : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Declaration declaration;
    /** */ Invariant invariant_;
    /** */ Postblit postblit;
}

///
class StructDeclaration : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token name;
    /** */ 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;
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

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

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

///
class TemplateArgumentList : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TemplateArgument[] items;
}

///
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[] items;
}

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

///
class TemplateSingleArgument : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token token;
}

///
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 TraitsExpression : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token identifier;
    /** */ TemplateArgumentList templateArgumentList;
}

///
class TryStatement : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
    /** */ Catches catches;
    /** */ Finally finally_;
}

///
class Type : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ TokenType[] typeConstructors;
    /** */ TypeSuffix[] typeSuffixes;
    /** */ Type2 type2;
}

///
class Type2 : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token basicType;
    /** */ Symbol symbol;
    /** */ TypeofExpression typeofExpression;
    /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
    /** */ TokenType typeConstructor;
    /** */ Type type;
}

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

///
class TypeSuffix : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Token delegateOrFunction;
    /** */ bool star;
    /** */ bool array;
    /** */ Type type;
    /** */ AssignExpression assignExpression;
    /** */ Parameters parameters;
    /** */ 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;
    /** */ Token prefix;
    /** */ Token suffix;
    /** */ UnaryExpression unaryExpression;
    /** */ NewExpression newExpression;
    /** */ DeleteExpression deleteExpression;
    /** */ CastExpression castExpression;
    /** */ FunctionCallExpression functionCallExpression;
    /** */ ArgumentList argumentList;
    /** */ IdentifierOrTemplateInstance identifierOrTemplateInstance;
    /** */ AssertExpression assertExpression;
    /** */ SliceExpression sliceExpression;
    /** */ IndexExpression indexExpression;
}

///
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 : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Type type;
    /** */ Declarator[] declarators;
    /** */ StorageClass storageClass;
    /** */ AutoDeclaration autoDeclaration;
}

///
class Vector : ASTNode
{
public:
    mixin(DEFAULT_ACCEPT);
    /** */ Type type;
}

///
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;
    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}

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