diff --git a/std/d/ast.d b/std/d/ast.d
index 10f39b3..4acb742 100755
--- a/std/d/ast.d
+++ b/std/d/ast.d
@@ -26,416 +26,415 @@ import std.d.lexer;
  */
 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(AssertStatement assertStatement) { assertStatement.accept(this); }
-	/** */ void visit(AssignExpression assignExpression) { assignExpression.accept(this); }
-	/** */ void visit(AssignStatement assignStatement) { assignStatement.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(ForeachRangeStatement foreachRangeStatement) { foreachRangeStatement.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(NonEmptyStatement nonEmptyStatement) { nonEmptyStatement.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(TraitsArgument traitsArgument) { traitsArgument.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(TypeConstructors typeConstructors) { typeConstructors.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); }
+    /** */ 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(AssertStatement assertStatement) { assertStatement.accept(this); }
+    /** */ void visit(AssignExpression assignExpression) { assignExpression.accept(this); }
+    /** */ void visit(AssignStatement assignStatement) { assignStatement.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(NonEmptyStatement nonEmptyStatement) { nonEmptyStatement.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(TraitsArgument traitsArgument) { traitsArgument.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(TypeConstructors typeConstructors) { typeConstructors.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);
+    /** */ 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;
+    /** */ Token operator;
+    /** */ ShiftExpression left;
+    /** */ ShiftExpression right;
 };
 
 ///
 class AddExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType operator;
-	/** */ AddExpression left;
-	/** */ MulExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType operator;
+    /** */ AddExpression left;
+    /** */ MulExpression right;
 }
 
 ///
 class AliasDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ Declarator declarator;
-	/** */ AliasInitializer[] initializations;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ Declarator declarator;
+    /** */ AliasInitializer[] initializers;
 }
 
 ///
 class AliasInitializer : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ Type type;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Type type;
 }
 
 ///
 class AliasThisDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
 }
 
 ///
 class AlignAttribute : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token intLiteral;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token intLiteral;
 }
 
 ///
 class AndAndExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AndAndExpression left;
-	/** */ OrExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AndAndExpression left;
+    /** */ OrExpression right;
 }
 
 ///
 class AndExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AndExpression left;
-	/** */ CmpExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AndExpression left;
+    /** */ CmpExpression right;
 }
 
 ///
 class ArgumentList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression[] arguments;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression[] items;
 }
 
 ///
 class Arguments : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ ArgumentList argumentList;
+    mixin(DEFAULT_ACCEPT);
+    /** */ ArgumentList argumentList;
 }
 
 ///
 class ArrayInitializer : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ ArrayMemberInitialization[] arrayMemberInitializations;
+    mixin(DEFAULT_ACCEPT);
+    /** */ ArrayMemberInitialization[] arrayMemberInitializations;
 }
 
 ///
 class ArrayLiteral : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ ArgumentList argumentList;
+    mixin(DEFAULT_ACCEPT);
+    /** */ ArgumentList argumentList;
 }
 
 ///
 class ArrayMemberInitialization : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
-	/** */ NonVoidInitializer nonVoidInitializer;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
+    /** */ NonVoidInitializer nonVoidInitializer;
 }
 
 ///
 class AsmAddExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType operator;
-	/** */ AsmAddExp left;
-	/** */ AsmMulExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType operator;
+    /** */ AsmAddExp left;
+    /** */ AsmMulExp right;
 }
 
 ///
 class AsmAndExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmEqualExp left;
-	/** */ AsmEqualExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmEqualExp left;
+    /** */ AsmEqualExp right;
 }
 
 ///
 class AsmBrExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmBrExp asmBrExp;
-	/** */ AsmEqualExp asmEqualExp;
-	/** */ AsmUnaExp asmUnaExp;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmBrExp asmBrExp;
+    /** */ AsmEqualExp asmEqualExp;
+    /** */ AsmUnaExp asmUnaExp;
 }
 
 ///
 class AsmEqualExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmRelExp left;
-	/** */ AsmRelExp right;
-	/** */ Token operator;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmRelExp left;
+    /** */ AsmRelExp right;
+    /** */ Token operator;
 }
 
 ///
 class AsmExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmLogOrExp left;
-	/** */ AsmExp middle;
-	/** */ AsmExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmLogOrExp left;
+    /** */ AsmExp middle;
+    /** */ AsmExp right;
 }
 
 ///
 class AsmInstruction : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifierOrIntegerOrOpcode;
-	/** */ bool hasAlign;
-	/** */ AsmExp asmExp;
-	/** */ Operands operands;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifierOrIntegerOrOpcode;
+    /** */ bool hasAlign;
+    /** */ AsmExp asmExp;
+    /** */ Operands operands;
 }
 
 ///
 class AsmLogAndExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmOrExp left;
-	/** */ AsmOrExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmOrExp left;
+    /** */ AsmOrExp right;
 }
 
 ///
 class AsmLogOrExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmLogAndExp left;
-	/** */ AsmLogAndExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmLogAndExp left;
+    /** */ AsmLogAndExp right;
 }
 
 ///
 class AsmMulExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType operator;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType operator;
     /** */ AsmMulExp left;
-	/** */ AsmBrExp right;
+    /** */ AsmBrExp right;
 
 }
 
@@ -443,380 +442,380 @@ public:
 class AsmOrExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmXorExp left;
-	/** */ AsmXorExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmXorExp left;
+    /** */ AsmXorExp right;
 }
 
 ///
 class AsmPrimaryExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ IdentifierChain identifierChain;
-	/** */ Register register;
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ IdentifierChain identifierChain;
+    /** */ Register register;
+    /** */ Token token;
 }
 
 ///
 class AsmRelExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmShiftExp left;
-	/** */ AsmShiftExp right;
-	/** */ Token operator;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmShiftExp left;
+    /** */ AsmShiftExp right;
+    /** */ Token operator;
 }
 
 ///
 class AsmShiftExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmAddExp left;
-	/** */ AsmAddExp right;
-	/** */ Token operator;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmAddExp left;
+    /** */ AsmAddExp right;
+    /** */ Token operator;
 }
 
 ///
 class AsmStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmInstruction[] asmInstructions;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmInstruction[] asmInstructions;
 }
 
 ///
 class AsmTypePrefix : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token left;
-	/** */ Token right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token left;
+    /** */ Token right;
 }
 
 ///
 class AsmUnaExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmTypePrefix asmTypePrefix;
-	/** */ AsmExp asmExp;
-	/** */ Token prefix;
-	/** */ AsmPrimaryExp asmPrimaryExp;
-	/** */ AsmUnaExp asmUnaExp;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmTypePrefix asmTypePrefix;
+    /** */ AsmExp asmExp;
+    /** */ Token prefix;
+    /** */ AsmPrimaryExp asmPrimaryExp;
+    /** */ AsmUnaExp asmUnaExp;
 }
 
 ///
 class AsmXorExp : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmAndExp left;
-	/** */ AsmAndExp right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmAndExp left;
+    /** */ AsmAndExp right;
 }
 
 ///
 class AssertExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assertion;
-	/** */ AssignExpression message;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assertion;
+    /** */ AssignExpression message;
 }
 
 ///
 class AssertStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssertExpression assertExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssertExpression assertExpression;
 }
 
 ///
 class AssignExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TernaryExpression ternaryExpression;
-	/** */ AssignExpression assignExpression;
-	/** */ TokenType operator;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TernaryExpression ternaryExpression;
+    /** */ AssignExpression assignExpression;
+    /** */ TokenType operator;
 }
 
 ///
 class AssignStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ PreIncDecExpression preIncDecExpression;
-	/** */ PostIncDecExpression postIncDecExpression;
-	/** */ UnaryExpression[] unaryExpressions;
-	/** */ AssignExpression[] assignExpressions;
-	/** */ TokenType[] assignOperators;
+    mixin(DEFAULT_ACCEPT);
+    /** */ PreIncDecExpression preIncDecExpression;
+    /** */ PostIncDecExpression postIncDecExpression;
+    /** */ UnaryExpression[] unaryExpressions;
+    /** */ AssignExpression[] assignExpressions;
+    /** */ TokenType[] assignOperators;
 }
 
 ///
 class AssocArrayLiteral : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ KeyValuePairs keyValuePairs;
+    mixin(DEFAULT_ACCEPT);
+    /** */ KeyValuePairs keyValuePairs;
 }
 
 ///
 class AtAttribute : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionCallExpression functionCallExpression;
-	/** */ ArgumentList argumentList;
-	/** */ Token identifier;
+    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);
-		foreach (dec; declarations)
-		{
-			if (dec !is null)
-				visitor.visit(dec);
-		}
-	}
-	/** */ Attribute attribute;
-	/** */ Declaration[] declarations;
+    override void accept(ASTVisitor visitor)
+    {
+        if (attribute !is null)
+            visitor.visit(attribute);
+        foreach (dec; declarations)
+        {
+            if (dec !is null)
+                visitor.visit(dec);
+        }
+    }
+    /** */ Attribute attribute;
+    /** */ Declaration[] declarations;
 }
 
 ///
 class Attribute : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ LinkageAttribute linkageAttribute;
-	/** */ AlignAttribute alignAttribute;
-	/** */ PragmaExpression pragmaExpression;
-	/** */ Deprecated deprecated_;
-	/** */ AtAttribute atAttribute;
-	/** */ TokenType attribute;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StorageClass storageClass;
+    /** */ Token[] identifiers;
+    /** */ Initializer[] initializers;
 }
 
 ///
 class BlockStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ DeclarationsAndStatements declarationsAndStatements;
+    mixin(DEFAULT_ACCEPT);
+    /** */ DeclarationsAndStatements declarationsAndStatements;
 }
 
 ///
 class BodyStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ BlockStatement blockStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ BlockStatement blockStatement;
 }
 
 ///
 class BreakStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ bool hasIdentifier;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ bool hasIdentifier;
 }
 
 ///
 class BaseClass : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ IdentifierOrTemplateChain identifierOrTemplateChain;
-	/** */ TypeofExpression typeofExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
+    /** */ TypeofExpression typeofExpression;
 }
 
 ///
 class BaseClassList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ BaseClass[] items;
+    mixin(DEFAULT_ACCEPT);
+    /** */ BaseClass[] items;
 }
 
 ///
 class CaseRangeStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression low;
-	/** */ AssignExpression high;
-	/** */ DeclarationsAndStatements declarationsAndStatements;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression low;
+    /** */ AssignExpression high;
+    /** */ DeclarationsAndStatements declarationsAndStatements;
 }
 
 ///
 class CaseStatement: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ ArgumentList argumentList;
-	/** */ DeclarationsAndStatements declarationsAndStatements;
+    mixin(DEFAULT_ACCEPT);
+    /** */ ArgumentList argumentList;
+    /** */ DeclarationsAndStatements declarationsAndStatements;
 }
 
 ///
 class CastExpression: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ CastQualifier castQualifier;
-	/** */ UnaryExpression unaryExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ CastQualifier castQualifier;
+    /** */ UnaryExpression unaryExpression;
 }
 
 ///
 class CastQualifier: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType first;
-	/** */ TokenType second;
-	/** */ bool hasSecond;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType first;
+    /** */ TokenType second;
+    /** */ bool hasSecond;
 }
 
 ///
 class Catches: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Catch[] catches;
-	/** */ LastCatch lastCatch;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Catch[] catches;
+    /** */ LastCatch lastCatch;
 }
 
 ///
 class Catch: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ Token identifier;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ Token identifier;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class ClassBody: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ DeclarationOrInvariant[] declarationOrInvariants;
+    mixin(DEFAULT_ACCEPT);
+    /** */ DeclarationOrInvariant[] declarationOrInvariants;
 }
 
 ///
 class ClassDeclaration: ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token name;
-	/** */ TemplateParameters templateParameters;
-	/** */ Constraint constraint;
-	/** */ BaseClassList baseClassList;
-	/** */ ClassBody classBody;
+    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;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ VersionCondition versionCondition;
+    /** */ DebugCondition debugCondition;
+    /** */ StaticIfCondition staticIfCondition;
 }
 
 ///
 class ConditionalDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ CompileCondition compileCondition;
-	/** */ Declaration[] trueDeclarations;
-	/** */ Declaration[] falseDeclarations;
+    mixin(DEFAULT_ACCEPT);
+    /** */ CompileCondition compileCondition;
+    /** */ Declaration[] trueDeclarations;
+    /** */ Declaration[] falseDeclarations;
 }
 
 ///
 class ConditionalStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ CompileCondition compileCondition;
-	/** */ StatementNoCaseNoDefault trueStatement;
-	/** */ StatementNoCaseNoDefault falseStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ CompileCondition compileCondition;
+    /** */ StatementNoCaseNoDefault trueStatement;
+    /** */ StatementNoCaseNoDefault falseStatement;
 }
 
 ///
 class Constraint : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
 }
 
 ///
 class Constructor : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Parameters parameters;
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Parameters parameters;
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class ContinueStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ bool hasIdentifier;
-	/** */ Token identifier;
+    mixin(DEFAULT_ACCEPT);
+    /** */ bool hasIdentifier;
+    /** */ Token identifier;
 }
 
 ///
 class DebugCondition : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifierOrInteger;
-	/** */ bool hasIdentifierOrInteger;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifierOrInteger;
+    /** */ bool hasIdentifierOrInteger;
 }
 
 ///
 class DebugSpecification : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifierOrInteger;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifierOrInteger;
 }
 
 ///
@@ -824,8 +823,8 @@ class Declaration : ASTNode
 {
 public:
 
-	override void accept(ASTVisitor visitor)
-	{
+    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);
@@ -850,278 +849,279 @@ public:
         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;
+    /** */ 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;
 }
 
 ///
 class DeclarationsAndStatements : ASTNode
 {
-	mixin(DEFAULT_ACCEPT);
-	/** */ ASTNode[] declarationsAndStatements;
+    mixin(DEFAULT_ACCEPT);
+    /** */ DeclarationOrStatement[] declarationsAndStatements;
 }
 
 ///
 class DeclarationOrInvariant : ASTNode
 {
     mixin(DEFAULT_ACCEPT);
-    Declaration declaration;
-    Invariant invariant_;
+    /** */ 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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Initializer initializer;
 }
 
 ///
 class DefaultStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ DeclarationsAndStatements declarationsAndStatements;
+    mixin(DEFAULT_ACCEPT);
+    /** */ DeclarationsAndStatements declarationsAndStatements;
 }
 
 ///
 class DeleteExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ UnaryExpression unaryExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ UnaryExpression unaryExpression;
 }
 
 ///
 class DeleteStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ DeleteExpression deleteExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ DeleteExpression deleteExpression;
 }
 
 ///
 class Deprecated : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class Destructor : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class DoStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
-	/** */ Expression expression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    /** */ Expression expression;
 }
 
 ///
 class EnumBody : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ EnumMember[] enumMembers;
+    mixin(DEFAULT_ACCEPT);
+    /** */ EnumMember[] enumMembers;
 }
 
 ///
 class EnumDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ Type type;
-	/** */ EnumBody enumBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Type type;
+    /** */ EnumBody enumBody;
 }
 
 ///
 class EnumMember : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ Type type;
-	/** */ AssignExpression assignExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Type type;
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class EqualExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType operator;
-	/** */ ShiftExpression left;
-	/** */ ShiftExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType operator;
+    /** */ ShiftExpression left;
+    /** */ ShiftExpression right;
 }
 
 ///
 class Expression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression[] items;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression[] items;
 }
 
 ///
 class ExpressionStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
 }
 
 ///
 class FinalSwitchStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ SwitchStatement switchStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ SwitchStatement switchStatement;
 }
 
 ///
 class Finally : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class ForStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Declaration initializationDeclaration;
-	/** */ Statement initializationStatement;
-	/** */ Expression test;
-	/** */ Expression increment;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
-}
-
-///
-class ForeachRangeStatement : ASTNode
-{
-public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ ForeachType foreachType;
-	/** */ Expression lower;
-	/** */ Expression higher;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Declaration initializationDeclaration;
+    /** */ Statement initializationStatement;
+    /** */ Expression test;
+    /** */ Expression increment;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class ForeachStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token foreachType;
-	/** */ ForeachTypeList foreachTypeList;
-	/** */ Expression expression;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType foreachType;
+    /** */ ForeachTypeList foreachTypeList;
+    /** */ Expression low;
+    /** */ Expression high;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class ForeachType : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ bool isRef;
-	/** */ Type type;
-	/** */ Token identifier;
+    mixin(DEFAULT_ACCEPT);
+    /** */ bool isRef;
+    /** */ Type type;
+    /** */ Token identifier;
 }
 
 ///
 class ForeachTypeList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ ForeachType[] items;
+    mixin(DEFAULT_ACCEPT);
+    /** */ ForeachType[] items;
 }
 
 ///
 class FunctionAttribute : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token token;
-	/** */ AtAttribute atAttribute;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token token;
+    /** */ AtAttribute atAttribute;
 }
 
 ///
 class FunctionBody : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ BlockStatement blockStatement;
-	/** */ BodyStatement bodyStatement;
-	/** */ OutStatement outStatement;
-	/** */ InStatement inStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ BlockStatement blockStatement;
+    /** */ BodyStatement bodyStatement;
+    /** */ OutStatement outStatement;
+    /** */ InStatement inStatement;
 }
 
 ///
 class FunctionCallExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ UnaryExpression unaryExpression;
-	/** */ TemplateArguments templateArguments;
-	/** */ Arguments arguments;
+    mixin(DEFAULT_ACCEPT);
+    /** */ UnaryExpression unaryExpression;
+    /** */ TemplateArguments templateArguments;
+    /** */ Arguments arguments;
 }
 
 ///
 class FunctionCallStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionCallExpression functionCallExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionCallExpression functionCallExpression;
 }
 
 ///
 class FunctionDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type returnType;
-	/** */ Token name;
-	/** */ TemplateParameters templateParameters;
-	/** */ Parameters parameters;
-	/** */ Constraint constraint;
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ bool hasAuto;
+    /** */ bool hasRef;
+    /** */ Type returnType;
+    /** */ Token name;
+    /** */ TemplateParameters templateParameters;
+    /** */ Parameters parameters;
+    /** */ Constraint constraint;
+    /** */ FunctionBody functionBody;
     /** */ MemberFunctionAttribute[] memberFunctionAttributes;
 }
 
@@ -1129,306 +1129,306 @@ public:
 class FunctionLiteralExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType functionOrDelegate;
-	/** */ Type type;
-	/** */ Parameters parameters;
-	/** */ FunctionAttribute[] functionAttributes;
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType functionOrDelegate;
+    /** */ Type type;
+    /** */ Parameters parameters;
+    /** */ FunctionAttribute[] functionAttributes;
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class GotoStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
+    /** */ Token token;
 }
 
 ///
 class IdentifierChain : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token[] identifiers;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token[] identifiers;
 }
 
 ///
 class IdentifierList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token[] identifiers;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token[] identifiers;
 }
 
 ///
 class IdentifierOrTemplateChain : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ IdentifierOrTemplateInstance[] identifierOrTemplateInstances;
+    mixin(DEFAULT_ACCEPT);
+    /** */ IdentifierOrTemplateInstance[] identifierOrTemplateInstances;
 }
 
 ///
 class IdentifierOrTemplateInstance : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ TemplateInstance templateInstance;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ TemplateInstance templateInstance;
 }
 
 ///
 class IdentityExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
+    mixin(DEFAULT_ACCEPT);
     /** */ bool negated;
-	/** */ ShiftExpression left;
-	/** */ ShiftExpression right;
+    /** */ ShiftExpression left;
+    /** */ ShiftExpression right;
 }
 
 ///
 class IfStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ StatementNoCaseNoDefault thenStatement;
-	/** */ StatementNoCaseNoDefault elseStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
+    /** */ StatementNoCaseNoDefault thenStatement;
+    /** */ StatementNoCaseNoDefault elseStatement;
 }
 
 ///
 class ImportBind : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token left;
-	/** */ Token right;
-	/** */ bool hasRight;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token left;
+    /** */ Token right;
+    /** */ bool hasRight;
 }
 
 ///
 class ImportBindings : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ SingleImport singleImport;
-	/** */ ImportBind[] importBinds;
+    mixin(DEFAULT_ACCEPT);
+    /** */ SingleImport singleImport;
+    /** */ ImportBind[] importBinds;
 }
 
 ///
 class ImportDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ SingleImport[] singleImports;
-	/** */ ImportBindings importBindings;
+    mixin(DEFAULT_ACCEPT);
+    /** */ SingleImport[] singleImports;
+    /** */ ImportBindings importBindings;
 }
 
 ///
 class ImportExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class ImportList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ SingleImport singleImport;
-	/** */ ImportList next;
-	/** */ ImportBindings bindings;
+    mixin(DEFAULT_ACCEPT);
+    /** */ SingleImport singleImport;
+    /** */ ImportList next;
+    /** */ ImportBindings bindings;
 }
 
 ///
 class IndexExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ UnaryExpression unaryExpression;
-	/** */ ArgumentList argumentList;
+    mixin(DEFAULT_ACCEPT);
+    /** */ UnaryExpression unaryExpression;
+    /** */ ArgumentList argumentList;
 }
 
 ///
 class InExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	mixin(SHIFT_SHIFT_BODY);
+    mixin(DEFAULT_ACCEPT);
+    mixin(SHIFT_SHIFT_BODY);
 }
 
 ///
 class InStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ BlockStatement blockStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ BlockStatement blockStatement;
 }
 
 ///
 class Initialize : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class Initializer : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ NonVoidInitializer nonVoidInitializer;
+    mixin(DEFAULT_ACCEPT);
+    /** */ NonVoidInitializer nonVoidInitializer;
 }
 
 ///
 class InterfaceDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ TemplateParameters templateParameters;
-	/** */ Constraint constraint;
-	/** */ BaseClassList baseClassList;
-	/** */ StructBody structBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ TemplateParameters templateParameters;
+    /** */ Constraint constraint;
+    /** */ BaseClassList baseClassList;
+    /** */ StructBody structBody;
 }
 
 ///
 class Invariant : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ BlockStatement blockStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ BlockStatement blockStatement;
 }
 
 ///
 class IsExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ AssignExpression assignExpression;
-	/** */ Token identifier;
-	/** */ TypeSpecialization typeSpecialization;
-	/** */ TemplateParameterList templateParameterList;
-	/** */ Token equalsOrColon;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ AssignExpression assignExpression;
+    /** */ Token identifier;
+    /** */ TypeSpecialization typeSpecialization;
+    /** */ TemplateParameterList templateParameterList;
+    /** */ Token equalsOrColon;
 }
 
 ///
 class KeyValuePair : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
+    mixin(DEFAULT_ACCEPT);
     /** */ AssignExpression key;
-	/** */ AssignExpression value;
+    /** */ AssignExpression value;
 }
 
 ///
 class KeyValuePairs : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ KeyValuePair[] keyValuePairs;
+    mixin(DEFAULT_ACCEPT);
+    /** */ KeyValuePair[] keyValuePairs;
 }
 
 ///
 class LabeledStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
+    mixin(DEFAULT_ACCEPT);
     Token identifier;
-	/** */ Statement statement;
+    /** */ Statement statement;
 }
 
 ///
 class LambdaExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ Parameters paramaters;
-	/** */ FunctionAttribute[] functionAttributes;
-	/** */ AssignExpression assignExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Parameters parameters;
+    /** */ FunctionAttribute[] functionAttributes;
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class LastCatch : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class LinkageAttribute : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ bool hasPlusPlus;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ bool hasPlusPlus;
 }
 
 ///
 class MemberFunctionAttribute : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token token;
-	/** */ FunctionAttribute functionAttribute;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token token;
+    /** */ FunctionAttribute functionAttribute;
 }
 
 ///
 class MixinDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ MixinExpression mixinExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ MixinExpression mixinExpression;
 }
 
 ///
 class MixinExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class MixinTemplateName : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ bool hasDot;
-	/** */ IdentifierOrTemplateChain identifierOrTemplateChain;
-	/** */ TypeofExpression typeofExpression;
+    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;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ IdentifierChain moduleName;
 }
 
 
@@ -1436,88 +1436,87 @@ public:
 class MulExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType operator;
-	/** */ MulExpression left;
-	/** */ UnaryExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType operator;
+    /** */ MulExpression left;
+    /** */ UnaryExpression right;
 }
 
 ///
 class NewAnonClassExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Arguments allocatorArguments;
-	/** */ Arguments constructorArguments;
-	/** */ BaseClassList baseClassList;
-	/** */ ClassBody classBody;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ NewAnonClassExpression newAnonClassExpression;
+    /** */ Arguments arguments;
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class NonEmptyStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
-	/** */ CaseStatement caseStatement;
-	/** */ CaseRangeStatement caseRangeStatement;
-	/** */ DefaultStatement defaultStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    /** */ CaseStatement caseStatement;
+    /** */ CaseRangeStatement caseRangeStatement;
+    /** */ DefaultStatement defaultStatement;
 }
 
 ///
 class StatementNoCaseNoDefault : 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;
-	/** */ TemplateMixinStatement templateMixinStatement;
-	/** */ VersionSpecification versionSpecification;
-	/** */ DebugSpecification debugSpecification;
-	/** */ FunctionCallStatement functionCallStatement;
-	/** */ ExpressionStatement expressionStatement;
+    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;
+    /** */ 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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
+    /** */ ArrayInitializer arrayInitializer;
+    /** */ StructInitializer structInitializer;
 
 }
 
@@ -1525,24 +1524,24 @@ public:
 class Operand : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AsmExp asmExp;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AsmExp asmExp;
 }
 
 ///
 class Operands : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Operand[] operands;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Operand[] operands;
 }
 
 ///
 class OrExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ OrExpression left;
+    mixin(DEFAULT_ACCEPT);
+    /** */ OrExpression left;
     /** */ XorExpression right;
 }
 
@@ -1550,64 +1549,64 @@ public:
 class OrOrExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ OrOrExpression left;
-	/** */ AndAndExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ OrOrExpression left;
+    /** */ AndAndExpression right;
 }
 
 ///
 class OutStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token parameter;
-	/** */ BlockStatement blockStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token parameter;
+    /** */ BlockStatement blockStatement;
 }
 
 ///
 class Parameter : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType[] parameterAttributes;
-	/** */ Type type;
-	/** */ Token name;
-	/** */ bool vararg;
-	/** */ AssignExpression default_;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType[] parameterAttributes;
+    /** */ Type type;
+    /** */ Token name;
+    /** */ bool vararg;
+    /** */ AssignExpression default_;
 }
 
 ///
 class Parameters : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Parameter[] parameters;
-	/** */ bool hasVarargs;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Parameter[] parameters;
+    /** */ bool hasVarargs;
 }
 
 ///
 class Postblit : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class PostIncDecExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token operator;
-	/** */ UnaryExpression unaryExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token operator;
+    /** */ UnaryExpression unaryExpression;
 }
 
 ///
 class PowExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ PowExpression left;
+    mixin(DEFAULT_ACCEPT);
+    /** */ PowExpression left;
     /** */ UnaryExpression right;
 }
 
@@ -1615,35 +1614,35 @@ public:
 class PragmaDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ PragmaExpression pragmaExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ PragmaExpression pragmaExpression;
 }
 
 ///
 class PragmaExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ ArgumentList argumentList;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ ArgumentList argumentList;
 }
 
 ///
 class PreIncDecExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token operator;
-	/** */ UnaryExpression unaryExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token operator;
+    /** */ UnaryExpression unaryExpression;
 }
 
 ///
 class PrimaryExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token primary;
-	/** */ Token identifier;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token primary;
+    /** */ Token identifier;
     /** */ IdentifierOrTemplateInstance identifierOrTemplateInstance;
     /** */ TokenType basicType;
     /** */ TypeofExpression typeofExpression;
@@ -1664,61 +1663,61 @@ public:
 class Register : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ Token intLiteral;
-	/** */ bool hasIntegerLiteral;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Token intLiteral;
+    /** */ bool hasIntegerLiteral;
 }
 
 ///
 class RelExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
+    mixin(DEFAULT_ACCEPT);
     /** */ TokenType operator;
-	/** */ RelExpression left;
-	/** */ ShiftExpression right;
+    /** */ RelExpression left;
+    /** */ ShiftExpression right;
 }
 
 ///
 class ReturnStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
 }
 
 ///
 class ScopeGuardStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class SharedStaticConstructor : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class SharedStaticDestructor : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class ShiftExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType operator;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType operator;
     /** */ ShiftExpression left;
     /** */ AddExpression right;
 }
@@ -1727,114 +1726,115 @@ public:
 class SingleImport : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ IdentifierChain identifierChain;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ IdentifierChain identifierChain;
 }
 
 ///
 class SliceExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression lower;
-	/** */ AssignExpression upper;
+    mixin(DEFAULT_ACCEPT);
+    /** */ UnaryExpression unaryExpression;
+    /** */ AssignExpression lower;
+    /** */ AssignExpression upper;
 }
 
 ///
 class Statement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
-	/** */ CaseStatement caseStatement;
-	/** */ CaseRangeStatement caseRangeStatement;
-	/** */ DefaultStatement defaultStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    /** */ CaseStatement caseStatement;
+    /** */ CaseRangeStatement caseRangeStatement;
+    /** */ DefaultStatement defaultStatement;
 }
 
 ///
 class StaticAssertDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StaticAssertStatement staticAssertStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StaticAssertStatement staticAssertStatement;
 }
 
 ///
 class StaticAssertStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssertStatement assertStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssertStatement assertStatement;
 }
 
 ///
 class StaticConstructor : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class StaticDestructor : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ FunctionBody functionBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ FunctionBody functionBody;
 }
 
 ///
 class StaticIfCondition : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
 }
 
 ///
 class StorageClass : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AtAttribute atAttribute;
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AtAttribute atAttribute;
+    /** */ Token token;
 }
 
 ///
 class StructBody : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StructBodyItem[] structBodyItems;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StructBodyItem[] structBodyItems;
 }
 
 class StructBodyItem : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Declaration declaration;
-	/** */ Invariant invariant_;
-	/** */ Postblit postblit;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Declaration declaration;
+    /** */ Invariant invariant_;
+    /** */ Postblit postblit;
 }
 
 ///
 class StructDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token name;
-	/** */ TemplateParameters templateParameters;
-	/** */ Constraint constraint;
-	/** */ StructBody structBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token name;
+    /** */ TemplateParameters templateParameters;
+    /** */ Constraint constraint;
+    /** */ StructBody structBody;
 }
 
 ///
 class StructInitializer : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StructMemberInitializers structMemberInitializers;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StructMemberInitializers structMemberInitializers;
 
 }
 
@@ -1842,371 +1842,373 @@ public:
 class StructMemberInitializer : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ bool hasIdentifier;
-	/** */ NonVoidInitializer nonVoidInitializer;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ bool hasIdentifier;
+    /** */ NonVoidInitializer nonVoidInitializer;
 }
 
 ///
 class StructMemberInitializers : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StructMemberInitializer[] structMemberInitializers;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StructMemberInitializer[] structMemberInitializers;
 }
 
 ///
 class SwitchBody : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Statement[] statements;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Statement[] statements;
 }
 
 ///
 class SwitchStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ SwitchBody switchBody;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
+    /** */ SwitchBody switchBody;
 }
 
 ///
 class Symbol : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ IdentifierOrTemplateChain identifierOrTemplateChain;
-	/** */ bool hasDot;
+    mixin(DEFAULT_ACCEPT);
+    /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
+    /** */ bool hasDot;
 }
 
 ///
 class SynchronizedStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class TemplateAliasParameter : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ Token identifier;
-	/** */ Type colonType;
-	/** */ Expression colonExpression;
-	/** */ Type assignType;
-	/** */ Expression assignExpression;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ AssignExpression assignExpression;
+    /** */ Symbol symbol;
 }
 
 ///
 class TemplateArgumentList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TemplateArgument[] items;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TemplateArgument[] items;
 }
 
 ///
 class TemplateArguments : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TemplateArgumentList templateArgumentList;
-	/** */ TemplateSingleArgument templateSingleArgument;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TemplateArgumentList templateArgumentList;
+    /** */ TemplateSingleArgument templateSingleArgument;
 }
 
 ///
 class TemplateDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ TemplateParameters templateParameters;
-	/** */ Constraint constraint;
-	/** */ Declaration[] declarations;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ TemplateParameters templateParameters;
+    /** */ Constraint constraint;
+    /** */ Declaration[] declarations;
 }
 
 ///
 class TemplateInstance : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Symbol symbol;
-	/** */ TemplateArguments templateArguments;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ TemplateArguments templateArguments;
 }
 
 ///
 class TemplateMixinStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ TemplateArguments templateArguments;
-	/** */ MixinTemplateName mixinTemplateName;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TemplateTypeParameter templateTypeParameter;
+    /** */ TemplateValueParameter templateValueParameter;
+    /** */ TemplateAliasParameter templateAliasParameter;
+    /** */ TemplateTupleParameter templateTupleParameter;
+    /** */ TemplateThisParameter templateThisParameter;
 }
 
 ///
 class TemplateParameterList : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TemplateParameter[] items;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TemplateParameter[] items;
 }
 
 ///
 class TemplateParameters : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TemplateParameterList templateParameterList;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TemplateParameterList templateParameterList;
 }
 
 ///
 class TemplateSingleArgument : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token token;
 }
 
 ///
 class TemplateThisParameter : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TemplateTypeParameter templateTypeParameter;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TemplateTypeParameter templateTypeParameter;
 }
 
 ///
 class TemplateTupleParameter : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
 }
 
 ///
 class TemplateTypeParameter : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ Type colonType;
-	/** */ Type assignType;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ Type colonType;
+    /** */ Type assignType;
 }
 
 ///
 class TemplateValueParameter : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ Token identifier;
-	/** */ Expression expression;
-	/** */ TemplateValueParameterDefault templateValueParameterDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ Token identifier;
+    /** */ Expression expression;
+    /** */ TemplateValueParameterDefault templateValueParameterDefault;
 }
 
 ///
 class TemplateValueParameterDefault : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
+    /** */ Token token;
 }
 
 ///
 class TernaryExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ OrOrExpression orOrExpression;
-	/** */ Expression expression;
-	/** */ TernaryExpression ternaryExpression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ OrOrExpression orOrExpression;
+    /** */ Expression expression;
+    /** */ TernaryExpression ternaryExpression;
 }
 
 ///
 class ThrowStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
 }
 
 ///
 class TraitsArgument : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ AssignExpression assignExpression;
-	/** */ Type type;
+    mixin(DEFAULT_ACCEPT);
+    /** */ AssignExpression assignExpression;
+    /** */ Type type;
 }
 
 ///
 class TraitsExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token identifier;
-	/** */ TraitsArgument[] traitsArguments;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ TraitsArgument[] traitsArguments;
 }
 
 ///
 class TryStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
-	/** */ Catches catches;
-	/** */ Finally finally_;
+    mixin(DEFAULT_ACCEPT);
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    /** */ Catches catches;
+    /** */ Finally finally_;
 }
 
 ///
 class Type : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType[] typeConstructors;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType[] typeConstructors;
     /** */ TypeSuffix[] typeSuffixes;
-	/** */ Type2 type2;
+    /** */ Type2 type2;
 }
 
 ///
 class Type2 : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token basicType;
-	/** */ Symbol symbol;
-	/** */ TypeofExpression typeofExpression;
-	/** */ IdentifierOrTemplateChain identifierOrTemplateChain;
-	/** */ TokenType typeConstructor;
-	/** */ Type type;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token basicType;
+    /** */ Symbol symbol;
+    /** */ TypeofExpression typeofExpression;
+    /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
+    /** */ TokenType typeConstructor;
+    /** */ Type type;
 }
 
 ///
 class TypeConstructors : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ TokenType[] items;
+    mixin(DEFAULT_ACCEPT);
+    /** */ TokenType[] items;
 }
 
 ///
 class TypeSpecialization : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token token;
-	/** */ Type type;
+    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;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ Expression expression;
 }
 
 ///
 class TypeofExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ Token return_;
+    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;
+    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;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token identifier;
+    /** */ TemplateParameters templateParameters;
+    /** */ Constraint constraint;
+    /** */ StructBody structBody;
 }
 
 ///
 class Unittest : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ BlockStatement blockStatement;
+    mixin(DEFAULT_ACCEPT);
+    /** */ BlockStatement blockStatement;
 }
 
 ///
 class VariableDeclaration : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Type type;
-	/** */ Declarator[] declarators;
-	/** */ StorageClass storageClass;
-	/** */ AutoDeclaration autoDeclaration;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Type type;
+    /** */ Declarator[] declarators;
+    /** */ StorageClass storageClass;
+    /** */ AutoDeclaration autoDeclaration;
 }
 
 ///
@@ -2221,42 +2223,41 @@ public:
 class VersionCondition : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token token;
 }
 
 ///
 class VersionSpecification : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Token token;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Token token;
 }
 
 ///
 class WhileStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class WithStatement : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ Expression expression;
-	/** */ Symbol symbol;
-	/** */ TemplateInstance templateInstance;
+    mixin(DEFAULT_ACCEPT);
+    /** */ Expression expression;
+    /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
 }
 
 ///
 class XorExpression : ASTNode
 {
 public:
-	mixin(DEFAULT_ACCEPT);
-	/** */ XorExpression left;
-	/** */ AndExpression right;
+    mixin(DEFAULT_ACCEPT);
+    /** */ XorExpression left;
+    /** */ AndExpression right;
 }
diff --git a/std/d/parser.d b/std/d/parser.d
index 23627d5..59f1868 100755
--- a/std/d/parser.d
+++ b/std/d/parser.d
@@ -23,7 +23,7 @@
  * definitions end with a semicolon (;).)
  * )
  *
- * The grammar for D starts with the $(LINK2 #.module, module) rule.
+ * The grammar for D starts with the $(LINK2 #module, module) rule.
  *
  * Examples:
  * ---
@@ -69,10 +69,10 @@ import std.algorithm;
 import std.array;
 version (unittest) import std.stdio;
 
-version = development;
-version = verbose;
+//version = development;
+//version = verbose;
 version(development) import std.stdio;
-version(verbose) import std.stdio;
+import std.stdio;
 
 // TODO: any place that says *expect(...) needs to be fixed
 
@@ -104,7 +104,7 @@ struct Parser
      */
     AddExpression parseAddExpression()
     {
-		version(verbose) writeln("parseAddExpression");
+        version(verbose) writeln("parseAddExpression");
         return parseLeftAssocBinaryExpression!(AddExpression, MulExpression,
             TokenType.plus, TokenType.minus, TokenType.tilde)();
     }
@@ -119,14 +119,48 @@ struct Parser
     AliasDeclaration parseAliasDeclaration()
     {
         auto node = new AliasDeclaration;
-        expect(TokenType.alias_);
-
-        // TODO
-
-        expect(TokenType.semicolon);
+        if (expect(TokenType.alias_) is null) return null;
+        if (startsWith(TokenType.identifier, TokenType.assign))
+        {
+            do
+            {
+                auto initializer = parseAliasInitializer();
+                if (initializer is null) return null;
+                node.initializers ~= initializer;
+                if (currentIs(TokenType.comma))
+                    advance();
+                else
+                    break;
+            }
+            while (true);
+        }
+        else
+        {
+            if ((node.type = parseType()) is null) return null;
+            writeln("type parsed");
+            if ((node.declarator = parseDeclarator()) is null) return null;
+            writeln("declarator parsed");
+        }
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
+    unittest
+    {
+        auto sourceCode =
+q{
+alias core.sys.posix.stdio.fileno fileno;
+}c;
+
+        Parser p = getParserForUnittest(sourceCode, "parseAliasDeclaration");
+
+        AliasDeclaration d = p.parseAliasDeclaration();
+        assert (d !is null);
+        assert (p.errorCount == 0);
+
+        stderr.writeln("Unittest for parseAliasDeclaration() passed.");
+    }
+
     /**
      * Parses an AliasInitializer
      * $(GRAMMAR $(RULEDEF aliasInitializer):
@@ -136,8 +170,10 @@ struct Parser
     AliasInitializer parseAliasInitializer()
     {
         auto node = new AliasInitializer;
-        node.identifier = *expect(TokenType.identifier);
-        expect(TokenType.assign);
+        auto i = expect(TokenType.identifier);
+        if (i is null) return null;
+        node.identifier = *i;
+        if (expect(TokenType.assign) is null) return null;
         node.type = parseType();
         return node;
     }
@@ -151,10 +187,11 @@ struct Parser
     AliasThisDeclaration parseAliasThisDeclaration()
     {
         auto node = new AliasThisDeclaration;
-        expect(TokenType.alias_);
-        node.identifier = *expect(TokenType.identifier);
-        expect(TokenType.this_);
-        expect(TokenType.semicolon);
+        if (expect(TokenType.alias_) is null) return null;
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        if (expect(TokenType.this_) is null) return null;
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -170,9 +207,11 @@ struct Parser
         expect(TokenType.align_);
         if (currentIs(TokenType.lParen))
         {
-            expect(TokenType.lParen);
-            node.intLiteral = *expect(TokenType.intLiteral);
-            expect(TokenType.rParen);
+            if (expect(TokenType.lParen) is null) return null;
+            auto intLit = expect(TokenType.intLiteral);
+            if (intLit is null) return null;
+            node.intLiteral = *intLit;
+            if (expect(TokenType.rParen) is null) return null;
         }
         return node;
     }
@@ -186,7 +225,7 @@ struct Parser
      */
     AndAndExpression parseAndAndExpression()
     {
-		version(verbose) writeln("parseAndAndExpression");
+        version(verbose) writeln("parseAndAndExpression");
         return parseLeftAssocBinaryExpression!(AndAndExpression, OrExpression,
             TokenType.logicAnd)();
     }
@@ -201,7 +240,7 @@ struct Parser
      */
     AndExpression parseAndExpression()
     {
-		version(verbose) writeln("parseAndExpression");
+        version(verbose) writeln("parseAndExpression");
         return parseLeftAssocBinaryExpression!(AndExpression, CmpExpression,
             TokenType.bitAnd)();
     }
@@ -215,19 +254,7 @@ struct Parser
      */
     ArgumentList parseArgumentList()
     {
-        auto node = new ArgumentList;
-        while (true)
-        {
-            node.arguments ~= parseAssignExpression();
-            if (moreTokens() && currentIs(TokenType.comma))
-            {
-                advance();
-                continue;
-            }
-            else
-                break;
-        }
-        return node;
+        return parseCommaSeparatedRule!(ArgumentList, AssignExpression)();
     }
 
     /**
@@ -240,9 +267,9 @@ struct Parser
     Arguments parseArguments()
     {
         auto node = new Arguments;
-        expect(TokenType.lParen);
+        if (expect(TokenType.lParen) is null) return null;
         node.argumentList = parseArgumentList();
-        expect(TokenType.rParen);
+        if (expect(TokenType.rParen) is null) return null;
         return node;
     }
 
@@ -257,7 +284,7 @@ struct Parser
     ArrayInitializer parseArrayInitializer()
     {
         auto node = new ArrayInitializer;
-        expect(TokenType.lBracket);
+        if (expect(TokenType.lBracket) is null) return null;
         while (true)
         {
             node.arrayMemberInitializations ~= parseArrayMemberInitialization();
@@ -270,7 +297,7 @@ struct Parser
                 break;
         }
 
-        expect(TokenType.rBracket);
+        if (expect(TokenType.rBracket) is null) return null;
         return node;
     }
 
@@ -284,9 +311,9 @@ struct Parser
     ArrayLiteral parseArrayLiteral()
     {
         auto node = new ArrayLiteral;
-        expect(TokenType.lBracket);
+        if (expect(TokenType.lBracket) is null) return null;
         node.argumentList = parseArgumentList();
-        expect(TokenType.rBracket);
+        if (expect(TokenType.rBracket) is null) return null;
         return node;
     }
 
@@ -300,7 +327,29 @@ struct Parser
     ArrayMemberInitialization parseArrayMemberInitialization()
     {
         auto node = new ArrayMemberInitialization;
-        // TODO
+        with (TokenType) switch (current.type)
+        {
+        case lBrace:
+        case lBracket:
+            node.nonVoidInitializer = parseNonVoidInitializer();
+            if (node.nonVoidInitializer is null) return null;
+            break;
+        default:
+            auto assignExpression = parseAssignExpression();
+            if (assignExpression is null) return null;
+            if (currentIs(colon))
+            {
+                node.assignExpression = assignExpression;
+                advance();
+                node.nonVoidInitializer = parseNonVoidInitializer();
+                if (node.nonVoidInitializer is null) return null;
+            }
+            else
+            {
+                node.nonVoidInitializer = new NonVoidInitializer;
+                node.nonVoidInitializer.assignExpression = assignExpression;
+            }
+        }
         return node;
     }
 
@@ -575,14 +624,14 @@ struct Parser
     {
         auto node = new AssertExpression;
         expect(TokenType.assert_);
-        expect(TokenType.lParen);
+        if (expect(TokenType.lParen) is null) return null;
         node.assertion = parseAssignExpression();
         if (currentIs(TokenType.comma))
         {
             advance();
             node.message = parseAssignExpression();
         }
-        expect(TokenType.rParen);
+        if (expect(TokenType.rParen) is null) return null;
         return node;
     }
 
@@ -611,7 +660,7 @@ struct Parser
      */
     AssignExpression parseAssignExpression()
     {
-		version(verbose) writeln("parseAssignExpression");
+        version(verbose) writeln("parseAssignExpression");
         auto node = new AssignExpression;
         node.ternaryExpression = parseTernaryExpression();
         if (currentIsOneOf(TokenType.assign, TokenType.unsignedShiftRightEqual,
@@ -638,7 +687,7 @@ struct Parser
     {
         auto node = new AssignStatement;
         // TODO
-        expect(TokenType.semicolon);
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -652,9 +701,9 @@ struct Parser
     AssocArrayLiteral parseAssocArrayLiteral()
     {
         auto node = new AssocArrayLiteral;
-        expect(TokenType.lBracket);
+        if (expect(TokenType.lBracket) is null) return null;
         node.keyValuePairs = parseKeyValuePairs();
-        expect(TokenType.rBracket);
+        if (expect(TokenType.rBracket) is null) return null;
         return node;
     }
 
@@ -668,7 +717,7 @@ struct Parser
     AtAttribute parseAtAttribute()
     {
         auto node = new AtAttribute;
-        expect(TokenType.at);
+        if (expect(TokenType.at) is null) return null;
         with (TokenType) switch (current().type)
         {
         case identifier:
@@ -681,9 +730,9 @@ struct Parser
             node.argumentList = parseArgumentList();
             expect(rParen);
             break;
-		default:
-			error(`"(", or identifier expected`);
-			return null;
+        default:
+            error(`"(", or identifier expected`);
+            return null;
         }
         return node;
     }
@@ -781,11 +830,15 @@ struct Parser
         switch (current().type)
         {
         case TokenType.colon:
+            advance();
+            auto dec = parseDeclaration();
+            if (dec is null) return null;
+            node.declarations ~= dec;
             break;
         case TokenType.lBrace:
             while (moreTokens() && !currentIs(TokenType.rBrace))
                 node.declarations ~= parseDeclaration();
-            expect(TokenType.rBrace);
+            if (expect(TokenType.rBrace) is null) return null;
             break;
         default:
             node.declarations ~= parseDeclaration();
@@ -818,11 +871,11 @@ struct Parser
     BlockStatement parseBlockStatement()
     {
         auto node = new BlockStatement();
-        expect(TokenType.lBrace);
+        if (expect(TokenType.lBrace) is null) return null;
         version (development) skipBraceContent();
         if (!currentIs(TokenType.rBrace))
             node.declarationsAndStatements = parseDeclarationsAndStatements();
-        expect(TokenType.rBrace);
+        if (expect(TokenType.rBrace) is null) return null;
         return node;
     }
 
@@ -856,7 +909,7 @@ struct Parser
         {
         case TokenType.identifier:
             node.identifier = advance();
-            expect(TokenType.semicolon);
+            if (expect(TokenType.semicolon) is null) return null;
             break;
         case TokenType.semicolon:
             advance();
@@ -881,7 +934,7 @@ struct Parser
         if (currentIs(TokenType.typeof_))
         {
             node.typeofExpression = parseTypeofExpression();
-            expect(TokenType.dot);
+            if (expect(TokenType.dot) is null) return null;
         }
         node.identifierOrTemplateChain = parseIdentifierOrTemplateChain();
         return node;
@@ -931,9 +984,9 @@ struct Parser
     {
         if (isBasicType(current().type))
             return advance();
-		error("Basic type expected");
-		Token t;
-		return t;
+        error("Basic type expected");
+        Token t;
+        return t;
     }
 
     /**
@@ -948,11 +1001,11 @@ struct Parser
         auto node = new CaseRangeStatement;
         expect(TokenType.case_);
         node.low = parseAssignExpression();
-        expect(TokenType.colon);
-        expect(TokenType.vararg);
+        if (expect(TokenType.colon) is null) return null;
+        if (expect(TokenType.vararg) is null) return null;
         expect(TokenType.case_);
         node.high = parseAssignExpression();
-        expect(TokenType.colon);
+        if (expect(TokenType.colon) is null) return null;
         node.declarationsAndStatements = parseDeclarationsAndStatements();
         return node;
     }
@@ -969,7 +1022,7 @@ struct Parser
         auto node = new CaseStatement;
         expect(TokenType.case_);
         node.argumentList = parseArgumentList();
-        expect(TokenType.colon);
+        if (expect(TokenType.colon) is null) return null;
         node.declarationsAndStatements = parseDeclarationsAndStatements();
         return node;
     }
@@ -985,12 +1038,12 @@ struct Parser
     {
         auto node = new CastExpression;
         expect(TokenType.cast_);
-        expect(TokenType.lParen);
+        if (expect(TokenType.lParen) is null) return null;
         if (isCastQualifier())
             node.castQualifier = parseCastQualifier();
         else
             node.type = parseType();
-        expect(TokenType.rParen);
+        if (expect(TokenType.rParen) is null) return null;
         node.unaryExpression = parseUnaryExpression();
         return node;
     }
@@ -1136,11 +1189,11 @@ incorrect;
     {
         auto node = new Catch;
         expect(TokenType.catch_);
-        expect(TokenType.lParen);
+        if (expect(TokenType.lParen) is null) return null;
         node.type = parseType();
         if (currentIs(TokenType.identifier))
             node.identifier = advance();
-        expect(TokenType.rParen);
+        if (expect(TokenType.rParen) is null) return null;
         node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
         return node;
     }
@@ -1186,9 +1239,14 @@ incorrect;
     ClassBody parseClassBody()
     {
         auto node = new ClassBody;
-        expect(TokenType.lBrace);
-        version (development) skipBraceContent();
-        expect(TokenType.rBrace);
+        if (expect(TokenType.lBrace) is null) return null;
+        while (moreTokens() && !currentIs(TokenType.rBrace))
+        {
+            auto doi = parseDeclarationOrInvariant();
+            if (doi !is null)
+                node.declarationOrInvariants ~= doi;
+        }
+        if (expect(TokenType.rBrace) is null) return null;
         return node;
     }
 
@@ -1227,7 +1285,7 @@ incorrect;
 q{class ClassOne {}
 class ClassTwo : Super {}
 class ClassThree(A, B) : Super {}
-class ClassFour(A, B) if (someTest()) : Super {}};
+class ClassFour(A, B) if (someTest()) : Super {}}c;
 
         Parser p = getParserForUnittest(sourceCode, "parseClassDeclaration");
 
@@ -1241,27 +1299,28 @@ class ClassFour(A, B) if (someTest()) : Super {}};
         auto classTwo = p.parseClassDeclaration();
         assert (classTwo.name == "ClassTwo", classTwo.name.value);
         assert (classTwo.baseClassList !is null);
-        assert (classTwo.baseClassList.baseClasses.length == 1,
-            to!string(classTwo.baseClassList.baseClasses.length));
+        assert (classTwo.baseClassList.items.length == 1,
+            to!string(classTwo.baseClassList.items.length));
         assert (classTwo.classBody.declarationOrInvariants.length == 0,
             to!string(classTwo.classBody.declarationOrInvariants.length));
 
         auto classThree = p.parseClassDeclaration();
         assert (classThree.name == "ClassThree", classThree.name.value);
         assert (classThree.templateParameters !is null);
+        assert (classThree.templateParameters.templateParameterList.items.length == 2);
         assert (classThree.baseClassList !is null);
-        assert (classThree.baseClassList.baseClasses.length == 1);
+        assert (classThree.baseClassList.items.length == 1);
         assert (classThree.classBody.declarationOrInvariants.length == 0,
             to!string(classThree.classBody.declarationOrInvariants.length));
 
-        auto classFour = p.parseClassDeclaration();
-        assert (classFour.name == "ClassFour", classFour.name.value);
-        assert (classFour.templateParameters !is null);
-        assert (classFour.baseClassList !is null);
-        assert (classFour.constraint !is null);
-        assert (classFour.baseClassList.baseClasses.length == 1);
-        assert (classFour.classBody.declarationOrInvariants.length == 0,
-            to!string(classFour.classBody.declarationOrInvariants.length));
+        //auto classFour = p.parseClassDeclaration();
+        //assert (classFour.name == "ClassFour", classFour.name.value);
+        //assert (classFour.templateParameters !is null);
+        //assert (classFour.baseClassList !is null);
+        //assert (classFour.constraint !is null);
+        //assert (classFour.baseClassList.items.length == 1);
+        //assert (classFour.classBody.declarationOrInvariants.length == 0,
+        //    to!string(classFour.classBody.declarationOrInvariants.length));
 
         stderr.writeln("Unittest for parseClassDeclaration() passed.");
     }
@@ -1279,7 +1338,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      */
     CmpExpression parseCmpExpression()
     {
-		version(verbose) writeln("parseCmpExpression");
+        version(verbose) writeln("parseCmpExpression");
         auto node = new CmpExpression;
         auto shift = parseShiftExpression();
         with (TokenType) switch (current().type)
@@ -1362,6 +1421,52 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     {
         auto node = new ConditionalDeclaration;
         node.compileCondition = parseCompileCondition();
+        if (currentIs(TokenType.lBrace))
+        {
+            advance();
+            do
+            {
+                auto dec = parseDeclaration();
+                if (dec is null) return null;
+                node.trueDeclarations ~= dec;
+                if (!moreTokens() || currentIs(TokenType.rBrace))
+                    break;
+            }
+            while (true);
+            if (expect(TokenType.rBrace) is null) return null;
+        }
+        else
+        {
+            auto dec = parseDeclaration();
+            if (dec is null) return null;
+            node.trueDeclarations ~= dec;
+        }
+
+        if(currentIs(TokenType.else_))
+            advance();
+        else
+            return node;
+
+        if (currentIs(TokenType.lBrace))
+        {
+            advance();
+            do
+            {
+                auto dec = parseDeclaration();
+                if (dec is null) return null;
+                node.falseDeclarations ~= dec;
+                if (!moreTokens() || currentIs(TokenType.rBrace))
+                    break;
+            }
+            while (true);
+            if (expect(TokenType.rBrace) is null) return null;
+        }
+        else
+        {
+            auto dec = parseDeclaration();
+            if (dec is null) return null;
+            node.falseDeclarations ~= dec;
+        }
         return node;
     }
 
@@ -1369,7 +1474,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      * Parses an ConditionalStatement
      *
      * $(GRAMMAR $(RULEDEF conditionalStatement):
-     *     $(RULE compileCondition) $(RULE statementNoCaseNoDefault) ($(LITERAL 'else') $(RULE nonEmptyStatementNoCaseNoDefault))?
+     *     $(RULE compileCondition) $(RULE statementNoCaseNoDefault) ($(LITERAL 'else') $(RULE statementNoCaseNoDefault))?
      *     ;)
      */
     ConditionalStatement parseConditionalStatement()
@@ -1395,13 +1500,10 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     Constraint parseConstraint()
     {
         auto node = new Constraint;
-        expect(TokenType.if_);
-        expect(TokenType.lParen);
-        version (development)
-            skipParenContent();
-        else
-            node.expression = parseExpression();
-        expect(TokenType.rParen);
+        if (expect(TokenType.if_) is null) return null;
+        if (expect(TokenType.lParen) is null) return null;
+        node.expression = parseExpression();
+        if (expect(TokenType.rParen) is null) return null;
         return node;
     }
 
@@ -1415,7 +1517,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     Constructor parseConstructor()
     {
         auto node = new Constructor;
-        expect(TokenType.this_);
+        if (expect(TokenType.this_) is null) return null;
         node.parameters = parseParameters();
         node.functionBody = parseFunctionBody();
         return node;
@@ -1430,13 +1532,13 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      */
     ContinueStatement parseContinueStatement()
     {
-        expect(TokenType.continue_);
+        if (expect(TokenType.continue_) is null) return null;
         auto node = new ContinueStatement;
         switch (current().type)
         {
         case TokenType.identifier:
             node.identifier = advance();
-            expect(TokenType.semicolon);
+            if (expect(TokenType.semicolon) is null) return null;
             break;
         case TokenType.semicolon:
             advance();
@@ -1458,7 +1560,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     DebugCondition parseDebugCondition()
     {
         auto node = new DebugCondition;
-        expect(TokenType.debug_);
+        if (expect(TokenType.debug_) is null) return null;
         if (currentIs(TokenType.lParen))
         {
             advance();
@@ -1470,7 +1572,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
                 error(`Integer literal or identifier expected`);
                 return null;
             }
-            expect(TokenType.rParen);
+            if (expect(TokenType.rParen) is null) return null;
         }
         else
             node.hasIdentifierOrInteger = false;
@@ -1487,8 +1589,8 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     DebugSpecification parseDebugSpecification()
     {
         auto node = new DebugSpecification;
-        expect(TokenType.debug_);
-        expect(TokenType.assign);
+        if (expect(TokenType.debug_) is null) return null;
+        if (expect(TokenType.assign) is null) return null;
         if (currentIsOneOf(TokenType.identifier, TokenType.intLiteral))
             node.identifierOrInteger = advance();
         else
@@ -1496,7 +1598,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
             error("Integer literal or identifier expected");
             return null;
         }
-        expect(TokenType.semicolon);
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -1533,122 +1635,138 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     {
         import std.stdio;
         auto node = new Declaration;
-        switch (current().type)
+        with (TokenType) switch (current().type)
         {
-        case TokenType.alias_:
-            if (startsWith(TokenType.alias_, TokenType.identifier, TokenType.this_))
+        case alias_:
+            if (startsWith(alias_, identifier, this_))
                 node.aliasThisDeclaration = parseAliasThisDeclaration();
             else
                 node.aliasDeclaration = parseAliasDeclaration();
             break;
-        case TokenType.class_:
+        case class_:
             node.classDeclaration = parseClassDeclaration();
             break;
-        case TokenType.this_:
+        case this_:
             node.constructor = parseConstructor();
             break;
-        case TokenType.tilde:
+        case tilde:
             node.destructor = parseDestructor();
             break;
-        case TokenType.enum_:
+        case enum_:
             node.enumDeclaration = parseEnumDeclaration();
             break;
-        case TokenType.import_:
+        case import_:
             node.importDeclaration = parseImportDeclaration();
             break;
-        case TokenType.interface_:
+        case interface_:
             node.interfaceDeclaration = parseInterfaceDeclaration();
             break;
-        case TokenType.mixin_:
+        case mixin_:
             node.mixinDeclaration = parseMixinDeclaration();
             break;
-        case TokenType.pragma_:
+        case pragma_:
             node.pragmaDeclaration = parsePragmaDeclaration();
             break;
-        case TokenType.shared_:
-            if (startsWith(TokenType.shared_, TokenType.static_, TokenType.this_))
+        case shared_:
+            if (startsWith(shared_, static_, this_))
                 node.sharedStaticConstructor = parseSharedStaticConstructor();
-            else if (startsWith(TokenType.shared_, TokenType.static_, TokenType.tilde))
+            else if (startsWith(shared_, static_, tilde))
                 node.sharedStaticDestructor = parseSharedStaticDestructor();
             else
                 node.attributedDeclaration = parseAttributedDeclaration();
             break;
-        case TokenType.static_:
-            if (startsWith(TokenType.static_, TokenType.this_))
+        case static_:
+            if (startsWith(static_, this_))
                 node.staticConstructor = parseStaticConstructor();
-            else if (startsWith(TokenType.static_, TokenType.tilde))
+            else if (startsWith(static_, tilde))
                 node.staticDestructor = parseStaticDestructor();
-            else if (startsWith(TokenType.static_, TokenType.if_))
+            else if (startsWith(static_, if_))
                 node.conditionalDeclaration = parseConditionalDeclaration();
             else
                 node.attributedDeclaration = parseAttributedDeclaration();
             break;
-        case TokenType.struct_:
+        case struct_:
             node.structDeclaration = parseStructDeclaration();
             break;
-        case TokenType.template_:
+        case template_:
             node.templateDeclaration = parseTemplateDeclaration();
             break;
-        case TokenType.union_:
+        case union_:
             node.unionDeclaration = parseUnionDeclaration();
             break;
-        case TokenType.unittest_:
+        case unittest_:
             node.unittest_ = parseUnittest();
             break;
-        case TokenType.bool_: .. case TokenType.wchar_:
-        case TokenType.identifier:
+        case bool_: .. case wchar_:
+        case identifier:
             Type type = parseType();
-            if (!currentIs(TokenType.identifier))
+            if (!currentIs(identifier))
             {
                 error("Identifier expected");
                 return null;
             }
-            if (peekIs(TokenType.lParen))
+            if (peekIs(lParen))
                 node.functionDeclaration = parseFunctionDeclaration(type);
             else
                 node.variableDeclaration = parseVariableDeclaration(type);
             break;
-        case TokenType.version_:
-			if (peekIs(TokenType.lParen))
-				node.conditionalDeclaration = parseConditionalDeclaration();
-			else if (peekIs(TokenType.assign))
-				node.versionSpecification = parseVersionSpecification();
-			else
-			{
-				error(`"=" or "(" expected following "version"`);
-				return null;
-			}
-			break;
-        case TokenType.debug_:
+        case version_:
+            if (peekIs(lParen))
+                node.conditionalDeclaration = parseConditionalDeclaration();
+            else if (peekIs(assign))
+                node.versionSpecification = parseVersionSpecification();
+            else
+            {
+                error(`"=" or "(" expected following "version"`);
+                return null;
+            }
+            break;
+        case debug_:
             node.conditionalDeclaration = parseConditionalDeclaration();
             break;
-		case TokenType.at:
-		case TokenType.extern_:
-		case TokenType.align_:
-		//case TokenType.pragma_:
-		case TokenType.deprecated_:
-		case TokenType.private_:
-		case TokenType.package_:
-		case TokenType.protected_:
-		case TokenType.public_:
-		case TokenType.export_:
-		//case TokenType.extern_:
-		case TokenType.final_:
-		case TokenType.synchronized_:
-		case TokenType.override_:
-		case TokenType.abstract_:
-		case TokenType.const_:
-		case TokenType.auto_:
-		case TokenType.scope_:
-		case TokenType.gshared:
-		//case TokenType.shared_:
-		case TokenType.immutable_:
-		case TokenType.inout_:
-		//case TokenType.static_:
-		case TokenType.pure_:
-		case TokenType.nothrow_:
-			node.attributedDeclaration = parseAttributedDeclaration();
-			break;
+        case auto_:
+            if (startsWith(auto_, ref_, identifier, lParen)
+                || startsWith(auto_, identifier, lParen))
+            {
+                node.functionDeclaration = parseFunctionDeclaration();
+            }
+            break;
+        case ref_:
+            if (startsWith(ref_, auto_, identifier, lParen)
+                || startsWith(ref_, identifier, lParen))
+            {
+                node.functionDeclaration = parseFunctionDeclaration();
+            }
+            else
+            {
+                error(`Declaration expected`);
+                return null;
+            }
+            break;
+        case at:
+        case extern_:
+        case align_:
+        case deprecated_:
+        case private_:
+        case package_:
+        case protected_:
+        case public_:
+        case export_:
+        case extern_:
+        case final_:
+        case synchronized_:
+        case override_:
+        case abstract_:
+        case const_:
+        case gshared:
+        case shared_:
+        case immutable_:
+        case inout_:
+        case static_:
+        case pure_:
+        case nothrow_:
+            node.attributedDeclaration = parseAttributedDeclaration();
+            break;
         default:
             error("Declaration expected");
             advance();
@@ -1660,14 +1778,31 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     /**
      * Parses DeclarationsAndStatements
      *
-    * $(GRAMMAR $(RULEDEF declarationsAndStatements):
-    *     ($(RULE declaration) | $(RULE statementNoCaseNoDefault))+
-    *     ;)
+     * $(GRAMMAR $(RULEDEF declarationsAndStatements):
+     *     $(RULE declarationOrStatement)+
+     *     ;
+     * $(RULEDEF declarationOrStatement):
+     *       $(RULE declaration)
+     *     | $(RULE statementNoCaseNoDefault)
+     *     ;)
      */
     DeclarationsAndStatements parseDeclarationsAndStatements()
     {
         auto node = new DeclarationsAndStatements;
-        // TODO
+		while (!currentIsOneOf(TokenType.rBrace) && moreTokens())
+        {
+            auto dos = new DeclarationOrStatement;
+            // "Any ambiguities in the grammar between Statements and
+            // Declarations are resolved by the declarations taking precedence."
+            if (isDeclaration())
+                dos.declaration = parseDeclaration();
+            else
+                dos.statement = parseStatementNoCaseNoDefault();
+            if (dos.statement !is null || dos.declaration !is null)
+                node.declarationsAndStatements ~= dos;
+            else
+                return null;
+        }
         return node;
     }
 
@@ -1699,8 +1834,8 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     Declarator parseDeclarator()
     {
         auto node = new Declarator;
-		auto id = expect(TokenType.identifier);
-		if (id is null) return null;
+        auto id = expect(TokenType.identifier);
+        if (id is null) return null;
         node.identifier = *id;
         if (currentIsOneOf(TokenType.lBracket, TokenType.star))
         {
@@ -1725,8 +1860,8 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     DefaultStatement parseDefaultStatement()
     {
         auto node = new DefaultStatement;
-        expect(TokenType.default_);
-        expect(TokenType.colon);
+        if (expect(TokenType.default_) is null) return null;
+        if (expect(TokenType.colon) is null) return null;
         node.declarationsAndStatements = parseDeclarationsAndStatements();
         return node;
     }
@@ -1741,7 +1876,8 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     DeleteExpression parseDeleteExpression()
     {
         auto node = new DeleteExpression;
-        // TODO
+        if (expect(TokenType.delete_) is null) return null;
+		node.unaryExpression = parseUnaryExpression();
         return node;
     }
 
@@ -1755,12 +1891,12 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     Deprecated parseDeprecated()
     {
         auto node = new Deprecated;
-        expect(TokenType.deprecated_);
+        if (expect(TokenType.deprecated_) is null) return null;
         if (currentIs(TokenType.lParen))
         {
             advance();
             node.assignExpression = parseAssignExpression();
-            expect(TokenType.rParen);
+            if (expect(TokenType.rParen) is null) return null;
         }
         return node;
     }
@@ -1775,10 +1911,10 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     Destructor parseDestructor()
     {
         auto node = new Destructor;
-        expect(TokenType.tilde);
-        expect(TokenType.this_);
-        expect(TokenType.lParen);
-        expect(TokenType.rParen);
+        if (expect(TokenType.tilde) is null) return null;
+        if (expect(TokenType.this_) is null) return null;
+        if (expect(TokenType.lParen) is null) return null;
+        if (expect(TokenType.rParen) is null) return null;
         node.functionBody = parseFunctionBody();
         return node;
     }
@@ -1804,13 +1940,13 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     DoStatement parseDoStatement()
     {
         auto node = new DoStatement;
-        expect(TokenType.do_);
+        if (expect(TokenType.do_) is null) return null;
         node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
-        expect(TokenType.while_);
-        expect(TokenType.lParen);
+        if (expect(TokenType.while_) is null) return null;
+        if (expect(TokenType.lParen) is null) return null;
         node.expression = parseExpression();
-        expect(TokenType.rParen);
-        expect(TokenType.semicolon);
+        if (expect(TokenType.rParen) is null) return null;
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -1858,7 +1994,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     EnumDeclaration parseEnumDeclaration()
     {
         auto node = new EnumDeclaration;
-        expect(TokenType.enum_);
+        if (expect(TokenType.enum_) is null) return null;
         if (currentIs(TokenType.identifier))
             node.identifier = advance();
         if (currentIs(TokenType.colon))
@@ -1894,7 +2030,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      */
     EqualExpression parseEqualExpression(ShiftExpression shift = null)
     {
-		version(verbose) writeln("parseEqualExpression");
+        version(verbose) writeln("parseEqualExpression");
         auto node = new EqualExpression;
         node.left = shift is null ? parseShiftExpression() : shift;
         if (currentIsOneOf(TokenType.equal, TokenType.notEqual))
@@ -1915,20 +2051,20 @@ class ClassFour(A, B) if (someTest()) : Super {}};
         return parseCommaSeparatedRule!(Expression, AssignExpression)();
     }
 
-	/**
-	 * Parses an ExpressionStatement
-	 *
-	 * $(GRAMMAR $(RULEDEF expressionStatement):
-	 *     $(RULE expression) $(LITERAL ';')
-	 *     ;)
-	 */
-	ExpressionStatement parseExpressionStatement(Expression expression = null)
-	{
-		auto node = new ExpressionStatement;
-		node.expression = expression is null ? parseExpression() : expression;
-		expect(TokenType.semicolon);
-		return node;
-	}
+    /**
+     * Parses an ExpressionStatement
+     *
+     * $(GRAMMAR $(RULEDEF expressionStatement):
+     *     $(RULE expression) $(LITERAL ';')
+     *     ;)
+     */
+    ExpressionStatement parseExpressionStatement(Expression expression = null)
+    {
+        auto node = new ExpressionStatement;
+        node.expression = expression is null ? parseExpression() : expression;
+        if (expect(TokenType.semicolon) is null) return null;
+        return node;
+    }
 
     /**
      * Parses a FinalSwitchStatement
@@ -1940,8 +2076,9 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     FinalSwitchStatement parseFinalSwitchStatement()
     {
         auto node = new FinalSwitchStatement;
-        expect(TokenType.final_);
+        if (expect(TokenType.final_) is null) return null;
         node.switchStatement = parseSwitchStatement();
+        if (node.switchStatement is null) return null;
         return node;
     }
 
@@ -1955,7 +2092,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     Finally parseFinally()
     {
         auto node = new Finally;
-        expect(TokenType.finally_);
+        if (expect(TokenType.finally_) is null) return null;
         node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
         return node;
     }
@@ -1964,27 +2101,18 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      * Parses a ForStatement
      *
      * $(GRAMMAR $(RULEDEF forStatement):
-     *     $(LITERAL 'for') $(LITERAL '$(LPAREN)') $(RULE declarationOrStatement) $(RULE expression)? $(LITERAL ';') $(RULE expression)? $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
+     *     $(LITERAL 'for') $(LITERAL '$(LPAREN)') $(RULE declarationOrStatement) $(RULE expression)? $(LITERAL ';') $(RULE expression)? $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
      *     ;)
      */
     ForStatement parseForStatement()
     {
         auto node = new ForStatement;
+        expect(TokenType.for_);
+        expect(TokenType.lParen);
         // TODO
-        return node;
-    }
-
-    /**
-     * Parses a ForeachRangeStatement
-     *
-     * $(GRAMMAR $(RULEDEF foreachRangeStatement):
-     *     $(LITERAL 'foreach') $(LITERAL '$(LPAREN)') $(RULE foreachType) $(LITERAL ';') $(RULE expression) $(LITERAL '..') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
-     *     ;)
-     */
-    ForeachRangeStatement parseForeachRangeStatement()
-    {
-        auto node = new ForeachRangeStatement;
-        // TODO
+        assert (0);
+        expect(TokenType.rParen);
+        node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
         return node;
     }
 
@@ -1992,13 +2120,25 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      * Parses a ForeachStatement
      *
      * $(GRAMMAR $(RULEDEF foreachStatement):
-     *     ($(LITERAL 'foreach') | $(LITERAL 'foreach_reverse')) $(LITERAL '$(LPAREN)') $(RULE foreachTypeList) $(LITERAL ';') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
+     *       ($(LITERAL 'foreach') | $(LITERAL 'foreach_reverse')) $(LITERAL '$(LPAREN)') $(RULE foreachTypeList) $(LITERAL ';') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
+     *     | $(LITERAL 'foreach') $(LITERAL '$(LPAREN)') $(RULE foreachType) $(LITERAL ';') $(RULE expression) $(LITERAL '..') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
      *     ;)
      */
     ForeachStatement parseForeachStatement()
     {
         auto node = new ForeachStatement;
-        // TODO
+
+        if (currentIs(TokenType.foreach_))
+        {
+            expect(TokenType.foreach_);
+        }
+        else
+        {
+            expect(TokenType.foreach_reverse_);
+        }
+        expect(TokenType.lParen);
+        expect(TokenType.rParen);
+        node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
         return node;
     }
 
@@ -2012,7 +2152,20 @@ class ClassFour(A, B) if (someTest()) : Super {}};
     ForeachType parseForeachType()
     {
         auto node = new ForeachType;
-        // TODO
+        if (currentIs(TokenType.ref_))
+        {
+            node.isRef = true;
+            advance();
+        }
+        if (currentIs(TokenType.identifier) && peekIsOneOf(TokenType.comma, TokenType.semicolon))
+        {
+            node.identifier = advance();
+            return node;
+        }
+        if ((node.type = parseType()) is null) return null;
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        node.identifier = *ident;
         return node;
     }
 
@@ -2037,7 +2190,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
      *     | $(LITERAL 'nothrow')
      *     ;)
      */
-    FunctionAttribute parseFunctionAttribute()
+    FunctionAttribute parseFunctionAttribute(bool validate = true)
     {
         auto node = new FunctionAttribute;
         with (TokenType) switch (current().type)
@@ -2050,7 +2203,9 @@ class ClassFour(A, B) if (someTest()) : Super {}};
             node.token = advance();
             break;
         default:
-            break;
+            if (validate)
+                error(`@attribute, "pure", or "nothrow" expected`);
+            return null;
         }
         return node;
     }
@@ -2164,7 +2319,7 @@ body {} // six
     {
         auto node = new FunctionCallStatement;
         node.functionCallExpression = parseFunctionCallExpression();
-        expect(TokenType.semicolon);
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -2186,15 +2341,28 @@ body {} // six
         switch (current.type)
         {
         case TokenType.auto_:
+            advance();
+            node.hasAuto = true;
+            if (currentIs(TokenType.ref_))
+            {
+                node.hasRef = true;
+                advance();
+            }
             break;
         case TokenType.ref_:
+            advance();
+            node.hasRef = true;
+            if (currentIs(TokenType.auto_))
+            {
+                node.hasAuto = true;
+                advance();
+            }
             break;
         default:
+            node.returnType = type is null ? parseType() : type;
             break;
         }
 
-        node.returnType = type is null ? parseType() : type;
-
         auto ident = expect(TokenType.identifier);
         if (ident is null) return null;
 
@@ -2253,7 +2421,7 @@ body {} // six
     GotoStatement parseGotoStatement()
     {
         auto node = new GotoStatement;
-        expect(TokenType.goto_);
+        if (expect(TokenType.goto_) is null) return null;
         with (TokenType) switch (current().type)
         {
         case identifier:
@@ -2264,11 +2432,11 @@ body {} // six
             node.token = advance();
             node.expression = parseExpression();
             break;
-		default:
-			error(`Identifier, "default", or "case" expected`);
-			return null;
+        default:
+            error(`Identifier, "default", or "case" expected`);
+            return null;
         }
-        expect(TokenType.semicolon);
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -2284,7 +2452,9 @@ body {} // six
         auto node = new IdentifierChain;
         while (true)
         {
-            node.identifiers ~= *expect(TokenType.identifier);
+            auto ident = expect(TokenType.identifier);
+            if (ident is null) return null;
+            node.identifiers ~= *ident;
             if (currentIs(TokenType.dot))
             {
                 advance();
@@ -2306,6 +2476,7 @@ body {} // six
         p.tokens = tokens.array();
         auto chain = p.parseIdentifierChain();
         assert (chain.identifiers == ["abcde", "frocegu", "creou", "faowe"]);
+        stderr.writeln("Unittest for parseIdentifierChain() passed.");
     }
 
     /**
@@ -2365,7 +2536,11 @@ body {} // six
         if (peekIs(TokenType.not))
             node.templateInstance = parseTemplateInstance();
         else
-            node.identifier = *expect(TokenType.identifier);
+        {
+            auto ident = expect(TokenType.identifier);
+            if (ident is null) return null;
+            node.identifier = *ident;
+        }
         return node;
     }
 
@@ -2378,11 +2553,15 @@ body {} // six
      */
     IdentityExpression parseIdentityExpression(ShiftExpression shift = null)
     {
+        version(verbose) writeln("parseIdentityExpression");
         auto node = new IdentityExpression;
         node.left = shift is null ? parseShiftExpression() : shift;
         if (currentIs(TokenType.not))
+        {
+            advance();
             node.negated = true;
-        expect(TokenType.is_);
+        }
+        if (expect(TokenType.is_) is null) return null;
         node.right = parseShiftExpression();
         return node;
     }
@@ -2397,16 +2576,16 @@ body {} // six
     IfStatement parseIfStatement()
     {
         auto node = new IfStatement;
-        expect(TokenType.if_);
-        expect(TokenType.lParen);
+        if (expect(TokenType.if_) is null) return null;
+        if (expect(TokenType.lParen) is null) return null;
         node.expression = parseExpression();
-        expect(TokenType.rParen);
+        if (expect(TokenType.rParen) is null) return null;
         node.thenStatement = parseStatementNoCaseNoDefault();
-		if (currentIs(TokenType.else_))
-		{
-			advance();
-			node.elseStatement = parseStatementNoCaseNoDefault();
-		}
+        if (currentIs(TokenType.else_))
+        {
+            advance();
+            node.elseStatement = parseStatementNoCaseNoDefault();
+        }
         return node;
     }
 
@@ -2420,20 +2599,15 @@ body {} // six
     ImportBind parseImportBind()
     {
         auto node = new ImportBind;
-        if (!currentIs(TokenType.identifier))
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        node.left = *ident;
+        if (currentIs(TokenType.assign))
         {
-            error("Identifier expected.");
-            return null;
-        }
-        if (peekIs(TokenType.assign))
-        {
-            node.left = advance();
             advance();
             node.hasRight = true;
             node.right = *expect(TokenType.identifier);
         }
-        else
-            node.left = advance();
         return node;
     }
 
@@ -2448,11 +2622,11 @@ body {} // six
     {
         auto node = new ImportBindings;
         node.singleImport = singleImport is null ? parseSingleImport() : singleImport;
-        expect(TokenType.colon);
+        if (expect(TokenType.colon) is null) return null;
         while (true)
         {
             node.importBinds ~= parseImportBind();
-            if (moreTokens() && currentIs(TokenType.comma))
+            if (currentIs(TokenType.comma))
                 advance();
             else
                 break;
@@ -2464,13 +2638,14 @@ body {} // six
      * Parses an ImportDeclaration
      *
      * $(GRAMMAR $(RULEDEF importDeclaration):
-     *     $(LITERAL 'import') ($(RULE singleImport) ($(LITERAL ',') $(RULE singleImport))* | $(RULE importBindings)) $(LITERAL ';')
+     *       $(LITERAL 'import') $(RULE singleImport) ($(LITERAL ',') $(RULE singleImport))* ($(LITERAL ',') $(RULE importBindings))? $(LITERAL ';')
+     *     | $(LITERAL 'import') $(RULE importBindings) $(LITERAL ';')
      *     ;)
      */
     ImportDeclaration parseImportDeclaration()
     {
         auto node = new ImportDeclaration;
-        expect(TokenType.import_);
+        if (expect(TokenType.import_) is null) return null;
         SingleImport si = parseSingleImport();
         if (currentIs(TokenType.colon))
             node.importBindings = parseImportBindings(si);
@@ -2482,15 +2657,24 @@ body {} // six
                 advance();
                 while (true)
                 {
-                    node.singleImports ~= parseSingleImport();
-                    if (moreTokens() && currentIs(TokenType.comma))
-                        advance();
-                    else
+                    auto single = parseSingleImport();
+                    if (currentIs(TokenType.colon))
+                    {
+                        node.importBindings = parseImportBindings(single);
                         break;
+                    }
+                    else
+                    {
+                        node.singleImports ~= single;
+                        if (currentIs(TokenType.comma))
+                            advance();
+                        else
+                            break;
+                    }
                 }
             }
         }
-        expect(TokenType.semicolon);
+        if (expect(TokenType.semicolon) is null) return null;
         return node;
     }
 
@@ -2503,6 +2687,7 @@ import io = std.stdio;
 import std.stdio: writefln, foo = writef;
 import io = std.stdio : foo = writefln;
 import foo, bar, baz;
+import core.stdc.stdio, std.string : KeepTerminator;
 }c;
 
         Parser p = getParserForUnittest(sourceCode, "parseImportDeclaration");
@@ -2537,6 +2722,12 @@ import foo, bar, baz;
         assert (six.singleImports.length == 3);
         assert (p.errorCount == 0);
 
+        ImportDeclaration seven = p.parseImportDeclaration();
+        assert (seven !is null);
+        assert (seven.singleImports.length == 1);
+        assert (seven.importBindings !is null);
+        assert (p.errorCount == 0);
+
         stderr.writeln("Unittest for parseImportDeclaration() passed.");
     }
 
@@ -2550,10 +2741,10 @@ import foo, bar, baz;
     ImportExpression parseImportExpression()
     {
         auto node = new ImportExpression;
-        expect(TokenType.import_);
-        expect(TokenType.lParen);
+        if (expect(TokenType.import_) is null) return null;
+        if (expect(TokenType.lParen) is null) return null;
         node.assignExpression = parseAssignExpression();
-        expect(TokenType.rParen);
+        if (expect(TokenType.rParen) is null) return null;
         return node;
     }
 
@@ -2587,7 +2778,7 @@ import foo, bar, baz;
         node.left = shift is null ? parseShiftExpression() : shift;
         if (currentIs(TokenType.not))
             advance();
-        expect(TokenType.in_);
+        if (expect(TokenType.in_) is null) return null;
         node.right = parseShiftExpression();
         return node;
     }
@@ -2602,7 +2793,7 @@ import foo, bar, baz;
     InStatement parseInStatement()
     {
         auto node = new InStatement;
-        expect(TokenType.in_);
+        if (expect(TokenType.in_) is null) return null;
         node.blockStatement = parseBlockStatement();
         return node;
     }
@@ -2650,13 +2841,10 @@ import foo, bar, baz;
     InterfaceDeclaration parseInterfaceDeclaration()
     {
         auto node = new InterfaceDeclaration;
-        expect(TokenType.interface_);
-        if (!currentIs(TokenType.identifier))
-        {
-            error("Identifier expected");
-            return null;
-        }
-        node.identifier = advance();
+        if (expect(TokenType.interface_) is null) return null;
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        node.identifier = *ident;
         if (currentIs(TokenType.lParen))
         {
             node.templateParameters = parseTemplateParameters();
@@ -2844,7 +3032,31 @@ invariant() foo();
     LambdaExpression parseLambdaExpression()
     {
         auto node = new LambdaExpression;
-        // TODO
+        if (currentIs(TokenType.identifier))
+            node.identifier = advance();
+        else if (currentIs(TokenType.lParen))
+        {
+            node.parameters = parseParameters();
+            do
+            {
+                auto attribute = parseFunctionAttribute(false);
+                if (attribute is null)
+                    break;
+                node.functionAttributes ~= attribute;
+            }
+            while (moreTokens());
+        }
+        else
+        {
+            error(`Identifier or argument list expected`);
+            return null;
+        }
+
+        if (expect(TokenType.goesTo) is null) return null;
+
+        if ((node.assignExpression = parseAssignExpression()) is null)
+            return null;
+
         return node;
     }
 
@@ -2969,9 +3181,9 @@ invariant() foo();
             m.moduleDeclaration = parseModuleDeclaration();
         while (moreTokens())
         {
-			auto declaration = parseDeclaration();
-			if (declaration !is null)
-				m.declarations ~= declaration;
+            auto declaration = parseDeclaration();
+            if (declaration !is null)
+                m.declarations ~= declaration;
         }
         return m;
     }
@@ -3001,7 +3213,7 @@ invariant() foo();
      */
     MulExpression parseMulExpression()
     {
-		version(verbose) writeln("parseMulExpression");
+        version(verbose) writeln("parseMulExpression");
         return parseLeftAssocBinaryExpression!(MulExpression, UnaryExpression,
             TokenType.star, TokenType.div, TokenType.mod)();
     }
@@ -3137,8 +3349,10 @@ invariant() foo();
             node.forStatement = parseForStatement();
             break;
         case foreach_:
-        // TODO
-            break;
+        case foreach_reverse_:
+            // TODO
+            advance();
+            return null;
         case switch_:
             node.switchStatement = parseSwitchStatement();
             break;
@@ -3172,20 +3386,28 @@ invariant() foo();
         case asm_:
             node.asmStatement = parseAsmStatement();
             break;
+        case final_:
+            if (peekIs(switch_))
+            {
+                node.finalSwitchStatement = parseFinalSwitchStatement();
+                break;
+            }
+            else
+            {
+                error(`"switch" expected`);
+                return null;
+            }
         case delete_:
-		case assert_:
+        case assert_:
         default:
-			node.expressionStatement = parseExpressionStatement();
+            node.expressionStatement = parseExpressionStatement();
             break;
-        // TODO: assignStatement
-        // TODO: finalSwitchStatement
-        // TODO: foreachRangeStatement
+
         // TODO: conditionalStatement
         // TODO: staticAssertStatement
         // TODO: templateMixinStatement
         // TODO: versionSpecification
         // TODO: debugSpecification
-        // TODO: functionCallStatement
         }
         return node;
     }
@@ -3202,12 +3424,12 @@ invariant() foo();
     NonVoidInitializer parseNonVoidInitializer()
     {
         auto node = new NonVoidInitializer;
-		if (currentIs(TokenType.lBrace))
-			node.structInitializer = parseStructInitializer();
-		else if (currentIs(TokenType.lBracket))
-			node.arrayInitializer = parseArrayInitializer();
-		else
-			node.assignExpression = parseAssignExpression();
+        if (currentIs(TokenType.lBrace))
+            node.structInitializer = parseStructInitializer();
+        else if (currentIs(TokenType.lBracket))
+            node.arrayInitializer = parseArrayInitializer();
+        else
+            node.assignExpression = parseAssignExpression();
         return node;
     }
 
@@ -3235,7 +3457,7 @@ invariant() foo();
      */
     OrExpression parseOrExpression()
     {
-		version(verbose) writeln("parseOrExpression");
+        version(verbose) writeln("parseOrExpression");
         return parseLeftAssocBinaryExpression!(OrExpression, XorExpression,
             TokenType.bitOr)();
     }
@@ -3250,7 +3472,7 @@ invariant() foo();
      */
     OrOrExpression parseOrOrExpression()
     {
-		version(verbose) writeln("parseOrOrExpression");
+        version(verbose) writeln("parseOrOrExpression");
         return parseLeftAssocBinaryExpression!(OrOrExpression, AndAndExpression,
             TokenType.logicOr)();
     }
@@ -3288,26 +3510,31 @@ invariant() foo();
         auto node = new Parameter;
         version (verbose) writeln("parseParameter");
         while (moreTokens())
-		{
-			TokenType type = parseParameterAttribute(false);
-			if (type == TokenType.invalid)
-				break;
-			else
-				node.parameterAttributes ~= type;
-		}
-		node.type = parseType();
-		if (node.type is null) return null;
-		if (currentIs(TokenType.identifier))
-		{
-			node.name = advance();
-			if (currentIs(TokenType.vararg))
-				node.vararg = true;
-			else if (currentIs(TokenType.assign))
-			{
-				advance();
-				node.default_ = parseAssignExpression();
-			}
-		}
+        {
+            TokenType type = parseParameterAttribute(false);
+            if (type == TokenType.invalid)
+                break;
+            else
+                node.parameterAttributes ~= type;
+        }
+        node.type = parseType();
+        if (node.type is null) return null;
+        if (currentIs(TokenType.identifier))
+        {
+            node.name = advance();
+            if (currentIs(TokenType.vararg))
+                node.vararg = true;
+            else if (currentIs(TokenType.assign))
+            {
+                advance();
+                node.default_ = parseAssignExpression();
+            }
+        }
+        else if (currentIs(TokenType.vararg))
+        {
+            node.vararg = true;
+            advance();
+        }
         return node;
     }
 
@@ -3328,27 +3555,27 @@ invariant() foo();
     TokenType parseParameterAttribute(bool validate = false)
     {
         with (TokenType) switch (current().type)
-		{
-		case immutable_:
-		case shared_:
-		case const_:
-		case inout_:
+        {
+        case immutable_:
+        case shared_:
+        case const_:
+        case inout_:
             if (peekIs(TokenType.lParen))
                 return invalid;
             else
                 goto case auto_;
-		case final_:
-		case in_:
-		case lazy_:
-		case out_:
-		case ref_:
-		case scope_:
-		case auto_:
-			return advance().type;
-		default:
-			if (validate) error("Parameter attribute expected");
-			return invalid;
-		}
+        case final_:
+        case in_:
+        case lazy_:
+        case out_:
+        case ref_:
+        case scope_:
+        case auto_:
+            return advance().type;
+        default:
+            if (validate) error("Parameter attribute expected");
+            return invalid;
+        }
     }
 
     /**
@@ -3365,54 +3592,63 @@ invariant() foo();
         version (verbose) writeln("parseParameters");
         auto node = new Parameters;
         expect(TokenType.lParen);
-		if (currentIs(TokenType.rParen))
-			goto end;
-		if (currentIs(TokenType.vararg))
-		{
-			node.hasVarargs = true;
-			goto end;
-		}
-		while (moreTokens())
-		{
-			if (currentIs(TokenType.vararg))
-			{
-				node.hasVarargs = true;
-				break;
-			}
-			if (currentIs(TokenType.rParen))
-				break;
-			auto param = parseParameter();
-			if (param is null)
-				break;
-			node.parameters ~= param;
-			if (currentIs(TokenType.comma))
-				advance();
-			else
-				break;
-		}
-	end:
+        if (currentIs(TokenType.rParen))
+            goto end;
+        if (currentIs(TokenType.vararg))
+        {
+            node.hasVarargs = true;
+            goto end;
+        }
+        while (moreTokens())
+        {
+            if (currentIs(TokenType.vararg))
+            {
+                advance();
+                node.hasVarargs = true;
+                break;
+            }
+            if (currentIs(TokenType.rParen))
+                break;
+            auto param = parseParameter();
+            if (param is null)
+                break;
+            node.parameters ~= param;
+            if (currentIs(TokenType.comma))
+                advance();
+            else
+                break;
+        }
+    end:
         expect(TokenType.rParen);
         return node;
     }
 
-	unittest
-	{
-		string sourceCode =
+    unittest
+    {
+        string sourceCode =
 q{(int a, ...)
-(double ...)}c;
+(double ...)
+(Range r)}c;
 
         Parser p = getParserForUnittest(sourceCode, "parseParameters");
 
-		Parameters params1 = p.parseParameters();
-		assert (params1.hasVarargs);
-		assert (params1.paramaters.length == 1);
-		assert (params1.paramaters[0].name == "a");
+        Parameters params1 = p.parseParameters();
+        assert (params1.hasVarargs);
+        assert (params1.parameters.length == 1);
+        assert (params1.parameters[0].name == "a");
 
-		Parameters params2 = p.parseParameters();
-		assert (params2.paramaters.length == 1);
-		assert (params2.paramaters[0].vararg);
-		assert (params2.paramaters[0].type !is null);
-	}
+        Parameters params2 = p.parseParameters();
+        assert (params2.parameters.length == 1);
+        assert (params2.parameters[0].vararg);
+        assert (params2.parameters[0].type !is null);
+
+        Parameters params3 = p.parseParameters();
+        assert (params3.parameters.length == 1);
+        assert (!params3.parameters[0].vararg);
+        assert (params3.parameters[0].type !is null);
+
+        stderr.writeln("Unittest for parseParameters() passed.");
+    }
 
     /**
      * Parses a Postblit
@@ -3563,7 +3799,7 @@ q{(int a, ...)
      */
     PrimaryExpression parsePrimaryExpression()
     {
-		version(verbose) writeln("parsePrimaryExpression");
+        version(verbose) writeln("parsePrimaryExpression");
         auto node = new PrimaryExpression;
         with (TokenType) switch (current().type)
         {
@@ -3632,12 +3868,11 @@ q{(int a, ...)
         case false_:
         mixin (SPECIAL_CASE_RANGE);
         mixin (LITERAL_CASE_RANGE);
-			version(verbose) writeln("special or literal ", index, " ", current());
             node.primary = advance();
             break;
-		default:
-			error(`Primary expression expected`);
-			return null;
+        default:
+            error(`Primary expression expected`);
+            return null;
         }
         return node;
     }
@@ -3780,7 +4015,7 @@ q{(int a, ...)
      */
     ShiftExpression parseShiftExpression()
     {
-		version(verbose) writeln("parseShiftExpression");
+        version(verbose) writeln("parseShiftExpression");
         return parseLeftAssocBinaryExpression!(ShiftExpression, AddExpression,
             TokenType.shiftLeft, TokenType.shiftRight,
             TokenType.unsignedShiftRight)();
@@ -3796,12 +4031,7 @@ q{(int a, ...)
     SingleImport parseSingleImport()
     {
         auto node = new SingleImport;
-        if (!currentIs(TokenType.identifier))
-        {
-            error("Identifier expected");
-            return null;
-        }
-        if (peekIs(TokenType.assign))
+        if (startsWith(TokenType.identifier, TokenType.assign))
         {
             node.identifier = advance();
             advance();
@@ -3810,6 +4040,25 @@ q{(int a, ...)
         return node;
     }
 
+    /**
+     * Parses a SliceExpression
+     *
+     * $(GRAMMAR $(RULEDEF sliceExpression):
+     *     $(RULE unaryExpression) $(LITERAL '[') $(RULE assignExpression) $(LITERAL '..') $(RULE assignExpression) $(LITERAL ']')
+     *     ;)
+     */
+    SliceExpression parseSliceExpression(UnaryExpression unary = null)
+    {
+        auto node = new SliceExpression;
+        node.unaryExpression = unary is null ? parseUnaryExpression() : unary;
+        expect(TokenType.lBrace);
+        node.lower = parseAssignExpression();
+        expect(TokenType.slice);
+        node.upper = parseAssignExpression();
+        expect(TokenType.rBrace);
+        return node;
+    }
+
     /**
      * Parses a Statement
      *
@@ -3946,12 +4195,8 @@ q{(int a, ...)
     {
         auto node = new StructBody;
         expect(TokenType.lBrace);
-		version (development)
-			skipBraceContent();
-		else
-			static assert (0);
-        //while (tokens[index] != TokenType.rBrace && moreTokens())
-        //    node.structBodyItems ~= parseStructBodyItem();
+        while (!currentIs(TokenType.rBrace) && moreTokens())
+            node.structBodyItems ~= parseStructBodyItem();
         expect(TokenType.rBrace);
         return node;
     }
@@ -4104,10 +4349,10 @@ q{(int a, ...)
     Symbol parseSymbol()
     {
         auto node = new Symbol;
-        if (tokens[index] == TokenType.dot)
+        if (currentIs(TokenType.dot))
         {
             node.hasDot = true;
-            ++index;
+            advance();
         }
         node.identifierOrTemplateChain = parseIdentifierOrTemplateChain();
         return node;
@@ -4208,6 +4453,7 @@ q{(int a, ...)
      */
     TemplateDeclaration parseTemplateDeclaration()
     {
+        version(verbose) writeln("parseTemplateDeclaration");
         auto node = new TemplateDeclaration;
         expect(TokenType.template_);
         node.identifier = *expect(TokenType.identifier);
@@ -4217,7 +4463,7 @@ q{(int a, ...)
         expect(TokenType.lBrace);
         do
             node.declarations ~= parseDeclaration();
-        while (!currentIs(TokenType.rBrace));
+        while (!currentIs(TokenType.rBrace) && moreTokens());
         expect(TokenType.rBrace);
         return node;
     }
@@ -4226,14 +4472,18 @@ q{(int a, ...)
      * Parses a TemplateInstance
      *
      * $(GRAMMAR $(RULEDEF templateInstance):
-     *     $(LITERAL symbol) $(RULE templateArguments)
+     *     $(LITERAL Identifier) $(RULE templateArguments)
      *     ;)
      */
     TemplateInstance parseTemplateInstance()
     {
         auto node = new TemplateInstance;
-        node.symbol = parseSymbol();
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        node.identifier = *ident;
         node.templateArguments = parseTemplateArguments();
+        if (node.templateArguments is null)
+            return null;
         return node;
     }
 
@@ -4248,12 +4498,12 @@ q{(int a, ...)
     {
         auto node = new TemplateMixinStatement;
         expect(TokenType.mixin_);
-		node.mixinTemplateName = parseMixinTemplateName();
-		if (currentIs(TokenType.not))
-			node.templateArguments = parseTemplateArguments();
-		if (currentIs(TokenType.identifier))
-			node.identifier = advance();
-		expect(TokenType.semicolon);
+        node.mixinTemplateName = parseMixinTemplateName();
+        if (currentIs(TokenType.not))
+            node.templateArguments = parseTemplateArguments();
+        if (currentIs(TokenType.identifier))
+            node.identifier = advance();
+        expect(TokenType.semicolon);
         return node;
     }
 
@@ -4270,8 +4520,28 @@ q{(int a, ...)
      */
     TemplateParameter parseTemplateParameter()
     {
+        version(verbose) writeln("parseTemplateParameter");
         auto node = new TemplateParameter;
-        // TODO
+        with (TokenType) switch (current.type)
+        {
+        case alias_:
+            node.templateAliasParameter = parseTemplateAliasParameter();
+            break;
+        case identifier:
+            if(peekIs(vararg))
+                node.templateTupleParameter = parseTemplateTupleParameter();
+            else if (peekIsOneOf(colon, assign, comma, rParen))
+                node.templateTypeParameter = parseTemplateTypeParameter();
+            else
+                node.templateValueParameter = parseTemplateValueParameter();
+            break;
+        case this_:
+            node.templateThisParameter = parseTemplateThisParameter();
+            break;
+        default:
+            node.templateValueParameter = parseTemplateValueParameter();
+            break;
+        }
         return node;
     }
 
@@ -4285,7 +4555,7 @@ q{(int a, ...)
     TemplateParameterList parseTemplateParameterList()
     {
         return parseCommaSeparatedRule!(TemplateParameterList, TemplateParameter)();
-	}
+    }
 
     /**
      * Parses TemplateParameters
@@ -4296,13 +4566,11 @@ q{(int a, ...)
      */
     TemplateParameters parseTemplateParameters()
     {
+        version(verbose) writeln("parseTemplateParameters");
         auto node = new TemplateParameters;
-        expect(TokenType.lParen);
-        version (development)
-			skipParenContent();
-		else
-			node.templateParameterList = parseTemplateParameterList();
-        expect(TokenType.rParen);
+        assert (expect(TokenType.lParen));
+        node.templateParameterList = parseTemplateParameterList();
+        assert (expect(TokenType.rParen));
         return node;
     }
 
@@ -4336,21 +4604,21 @@ q{(int a, ...)
     {
         auto node = new TemplateSingleArgument;
         with (TokenType) switch (current().type)
-		{
-		case true_:
-		case false_:
-		case null_:
-		case this_:
-		case identifier:
-		mixin (SPECIAL_CASE_RANGE);
-		mixin (LITERAL_CASE_RANGE);
-		mixin (BASIC_TYPE_CASE_RANGE);
-			node.token = advance();
-			break;
-		default:
-			error(`Invalid template argument. (Try enclosing in parenthesis?)`);
-			return null;
-		}
+        {
+        case true_:
+        case false_:
+        case null_:
+        case this_:
+        case identifier:
+        mixin (SPECIAL_CASE_RANGE);
+        mixin (LITERAL_CASE_RANGE);
+        mixin (BASIC_TYPE_CASE_RANGE);
+            node.token = advance();
+            break;
+        default:
+            error(`Invalid template argument. (Try enclosing in parenthesis?)`);
+            return null;
+        }
         return node;
     }
 
@@ -4365,7 +4633,7 @@ q{(int a, ...)
     {
         auto node = new TemplateThisParameter;
         expect(TokenType.this_);
-		node.templateTypeParameter = parseTemplateTypeParameter();
+        node.templateTypeParameter = parseTemplateTypeParameter();
         return node;
     }
 
@@ -4378,6 +4646,7 @@ q{(int a, ...)
      */
     TemplateTupleParameter parseTemplateTupleParameter()
     {
+        version(verbose) writeln("parseTemplateTupleParameter");
         auto node = new TemplateTupleParameter;
         auto i = expect(TokenType.identifier);
         if (i is null)
@@ -4397,7 +4666,19 @@ q{(int a, ...)
     TemplateTypeParameter parseTemplateTypeParameter()
     {
         auto node = new TemplateTypeParameter;
-        // TODO
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        node.identifier = *ident;
+        if (currentIs(TokenType.colon))
+        {
+            advance();
+            node.colonType = parseType();
+        }
+        else if (currentIs(TokenType.assign))
+        {
+            advance();
+            node.assignType = parseType();
+        }
         return node;
     }
 
@@ -4451,7 +4732,7 @@ q{(int a, ...)
      */
     TernaryExpression parseTernaryExpression()
     {
-		version(verbose) writeln("parseTernaryExpression");
+        version(verbose) writeln("parseTernaryExpression");
         auto node = new TernaryExpression;
         node.orOrExpression = parseOrOrExpression();
         if (currentIs(TokenType.ternary))
@@ -4507,10 +4788,13 @@ q{(int a, ...)
         auto node = new TraitsExpression;
         expect(TokenType.traits);
         expect(TokenType.lParen);
-        node.identifier = *expect(TokenType.identifier);
+        auto ident = expect(TokenType.identifier);
+        if (ident is null)
+            return null;
+        node.identifier = *ident;
         do
         {
-            expect(TokenType.comma);
+            if(expect(TokenType.comma) is null) return null;
             node.traitsArguments ~= parseTraitsArgument();
         }
         while (moreTokens() && currentIs(TokenType.comma));
@@ -4553,8 +4837,8 @@ q{(int a, ...)
         case TokenType.immutable_:
         case TokenType.inout_:
         case TokenType.shared_:
-			if (!peekIs(TokenType.lParen))
-				node.typeConstructors = parseTypeConstructors();
+            if (!peekIs(TokenType.lParen))
+                node.typeConstructors = parseTypeConstructors();
             break;
         default:
             break;
@@ -4643,17 +4927,17 @@ q{(int a, ...)
     TokenType parseTypeConstructor(bool validate = true)
     {
         with (TokenType) switch (current().type)
-		{
-		case const_:
-		case immutable_:
-		case inout_:
-		case shared_:
-			return advance().type;
-		default:
-			if (validate)
-				error(`"const", "immutable", "inout", or "shared" expected`);
-			return invalid;
-		}
+        {
+        case const_:
+        case immutable_:
+        case inout_:
+        case shared_:
+            return advance().type;
+        default:
+            if (validate)
+                error(`"const", "immutable", "inout", or "shared" expected`);
+            return invalid;
+        }
     }
 
     /**
@@ -4666,15 +4950,15 @@ q{(int a, ...)
     TokenType[] parseTypeConstructors()
     {
         TokenType[] r;
-		while (moreTokens())
-		{
-			TokenType type = parseTypeConstructor(false);
-			if (type == TokenType.invalid)
-				break;
-			else
-				r ~= type;
-		}
-		return r;
+        while (moreTokens())
+        {
+            TokenType type = parseTypeConstructor(false);
+            if (type == TokenType.invalid)
+                break;
+            else
+                r ~= type;
+        }
+        return r;
     }
 
     /**
@@ -4702,26 +4986,26 @@ q{(int a, ...)
     {
         auto node = new TypeSpecialization;
         with (TokenType) switch (current().type)
-		{
-		case struct_:
-		case union_:
-		case interface_:
-		case enum_:
-		case function_:
-		case delegate_:
-		case super_:
-		case const_:
-		case immutable_:
-		case inout_:
-		case shared_:
-		case return_:
-		case parameters:
-			node.token = advance();
-			break;
-		default:
-			node.type = parseType();
-			break;
-		}
+        {
+        case struct_:
+        case union_:
+        case interface_:
+        case enum_:
+        case function_:
+        case delegate_:
+        case super_:
+        case const_:
+        case immutable_:
+        case inout_:
+        case shared_:
+        case return_:
+        case parameters:
+            node.token = advance();
+            break;
+        default:
+            node.type = parseType();
+            break;
+        }
         return node;
     }
 
@@ -4766,7 +5050,7 @@ q{(int a, ...)
             advance();
             node.parameters = parseParameters();
             while (currentIsMemberFunctionAttribute())
-				node.memberFunctionAttributes ~= parseMemberFunctionAttribute();
+                node.memberFunctionAttributes ~= parseMemberFunctionAttribute();
             return node;
         default:
             error(`"*", "[", "delegate", or "function" expected.`);
@@ -4827,18 +5111,18 @@ q{(int a, ...)
      *     | $(RULE newExpression)
      *     | $(RULE deleteExpression)
      *     | $(RULE castExpression)
-	 *     | $(RULE assertExpression)
+     *     | $(RULE assertExpression)
      *     | $(RULE functionCallExpression)
      *     | $(RULE sliceExpression)
      *     | $(RULE indexExpression)
      *     | $(RULE unaryExpression) $(LITERAL '.') $(RULE identifierOrTemplateInstance)
-	 *     | $(RULE unaryExpression) ($(LITERAL '--')
-	 *     | $(RULE unaryExpression) ($(LITERAL '++')
+     *     | $(RULE unaryExpression) $(LITERAL '--')
+     *     | $(RULE unaryExpression) $(LITERAL '++')
      *     ;)
      */
     UnaryExpression parseUnaryExpression()
     {
-		version(verbose) writeln("parseUnaryExpression");
+        version(verbose) writeln("parseUnaryExpression");
         auto node = new UnaryExpression;
         with(TokenType) switch (current().type)
         {
@@ -4848,7 +5132,7 @@ q{(int a, ...)
         case plus:
         case minus:
         case tilde:
-		case increment:
+        case increment:
         case decrement:
             node.prefix = advance();
             node.unaryExpression = parseUnaryExpression();
@@ -4865,47 +5149,63 @@ q{(int a, ...)
         case assert_:
             node.assertExpression = parseAssertExpression();
             return node;
-		default:
-			node.primaryExpression = parsePrimaryExpression();
+        default:
+            node.primaryExpression = parsePrimaryExpression();
         }
 
-		loop: while (true) with (TokenType) switch (current().type)
-		{
-		case not:
-			index++;
-			bool jump = peekPastParens().type == TokenType.lParen;
-			index--;
-			if (jump)
-				goto case lParen;
-			else
-			{
-				error(`Function call expected`);
-				return null;
-			}
-		case lParen:
-			auto n = new UnaryExpression();
-			n.functionCallExpression = parseFunctionCallExpression(node);
-			node = n;
-			break;
-		case increment:
-		case decrement:
-			auto n = new UnaryExpression();
-			n.unaryExpression = node;
-			n.suffix = advance();
-			node = n;
-			break;
-		case lBracket:
-			assert (false);
-		case dot:
-			advance();
-			auto n = new UnaryExpression();
-			n.unaryExpression = node;
-			n.identifierOrTemplateInstance = parseIdentifierOrTemplateInstance();
-			break;
-		default:
-			break loop;
-		}
-		return node;
+        loop: while (moreTokens()) with (TokenType) switch (current().type)
+        {
+        case not:
+            index++;
+            bool jump =  (currentIs(TokenType.lParen) && peekPastParens().type == TokenType.lParen)
+                || peekIs(TokenType.lParen);
+            index--;
+            if (jump)
+                goto case lParen;
+            else
+                break loop;
+        case lParen:
+            auto n = new UnaryExpression();
+            n.functionCallExpression = parseFunctionCallExpression(node);
+            node = n;
+            break;
+        case increment:
+        case decrement:
+            auto n = new UnaryExpression();
+            n.unaryExpression = node;
+            n.suffix = advance();
+            node = n;
+            break;
+        case lBracket:
+            auto n = new UnaryExpression;
+            if (isSliceExpression())
+                n.sliceExpression = parseSliceExpression(node);
+            else
+                n.indexExpression = parseIndexExpression(node);
+            node = n;
+            break;
+        case dot:
+            advance();
+            auto n = new UnaryExpression();
+            n.unaryExpression = node;
+            n.identifierOrTemplateInstance = parseIdentifierOrTemplateInstance();
+            node = n;
+            break;
+        default:
+            break loop;
+        }
+        return node;
+    }
+
+    unittest
+    {
+        auto sourceCode =
+q{doStuff(5)}c;
+        Parser p = getParserForUnittest(sourceCode, "parseUnaryExpression");
+        auto unary = p.parseUnaryExpression();
+        assert (unary !is null);
+        assert (unary.functionCallExpression !is null);
+        stderr.writeln("Unittest for parseUnaryExpression() passed.");
     }
 
     /**
@@ -4919,7 +5219,9 @@ q{(int a, ...)
     {
         auto node = new UnionDeclaration;
         expect(TokenType.union_);
-        node.identifier = *expect(TokenType.identifier);
+        auto ident = expect(TokenType.identifier);
+        if (ident is null) return null;
+        node.identifier = *ident;
         if (currentIs(TokenType.lParen))
         {
             node.templateParameters = parseTemplateParameters();
@@ -4964,25 +5266,25 @@ q{(int a, ...)
     {
         auto node = new VariableDeclaration;
 
-		if (currentIs(TokenType.auto_))
-		{
-			node.autoDeclaration = parseAutoDeclaration();
-			return node;
-		}
+        if (currentIs(TokenType.auto_))
+        {
+            node.autoDeclaration = parseAutoDeclaration();
+            return node;
+        }
 
-		node.type = type is null ? parseType() : type;
+        node.type = type is null ? parseType() : type;
 
-		while(true)
-		{
-			auto declarator = parseDeclarator();
-			if (declarator is null) return null;
-			node.declarators ~= declarator;
-			if (moreTokens() && currentIs(TokenType.comma))
-				advance();
-			else
-				break;
-		}
-		expect(TokenType.semicolon);
+        while(true)
+        {
+            auto declarator = parseDeclarator();
+            if (declarator is null) return null;
+            node.declarators ~= declarator;
+            if (moreTokens() && currentIs(TokenType.comma))
+                advance();
+            else
+                break;
+        }
+        expect(TokenType.semicolon);
         return node;
     }
 
@@ -5073,17 +5375,18 @@ q{(int a, ...)
      * Parses a WithStatement
      *
      * $(GRAMMAR $(RULEDEF withStatement):
-     *     $(LITERAL 'with') $(LITERAL '$(LPAREN)') ($(RULE expression) | $(RULE symbol) | $(RULE templateInstance)) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
+     *     $(LITERAL 'with') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
      *     ;)
      */
     WithStatement parseWithStatement()
     {
         auto node = new WithStatement;
-        expect(TokenType.with_);
-        expect(TokenType.lParen);
-        // TODO: magic here
-        expect(TokenType.rParen);
-        parseStatementNoCaseNoDefault();
+        if (expect(TokenType.with_) is null) return null;
+        if (expect(TokenType.lParen) is null) return null;
+        if ((node.expression = parseExpression()) is null) return null;
+        if (expect(TokenType.rParen) is null) return null;
+        node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
+        if (node.statementNoCaseNoDefault is null) return null;
         return node;
     }
 
@@ -5097,7 +5400,7 @@ q{(int a, ...)
      */
     XorExpression parseXorExpression()
     {
-		version(verbose) writeln("parseXorExpression");
+        version(verbose) writeln("parseXorExpression");
         return parseLeftAssocBinaryExpression!(XorExpression, AndExpression,
             TokenType.xor)();
     }
@@ -5105,6 +5408,16 @@ q{(int a, ...)
 private:
 
     bool isAssociativeArrayLiteral()
+    {
+        return hasMagicDelimiter!(TokenType.colon)();
+    }
+
+    bool isSliceExpression()
+    {
+        return hasMagicDelimiter!(TokenType.slice)();
+    }
+
+    bool hasMagicDelimiter(alias T)()
     {
         auto i = index;
         scope(exit) index = i;
@@ -5117,56 +5430,25 @@ private:
         case lParen: skipParenContent(); break;
         case lBracket: skipBracketContent(); break;
         case rBracket: return false;
-        case colon: return true;
+        case T: return true;
         default: break;
         }
         return false;
     }
 
-    bool isStatement() const
+    bool isDeclaration()
     {
-        // TODO: Not complete
-        with (TokenType) switch (current().type)
-        {
-        case lBrace:
-        case if_:
-        case while_:
-        case do_:
-        case for_:
-        case foreach_:
-        case foreach_reverse_:
-        case switch_:
-        case continue_:
-        case break_:
-        case return_:
-        case goto_:
-        case with_:
-        case try_:
-        case throw_:
-        case asm_:
-        case default_:
-        case case_:
-        case new_:
-        mixin (SPECIAL_CASE_RANGE);
-        mixin (LITERAL_CASE_RANGE);
-        case true_:
-        case false_:
-            return true;
-        case extern_:
-        case union_:
-        case class_:
-        case interface_:
-        case function_:
-        case delegate_:
-        case typedef_:
-        case typeof_:
-        case invariant_:
-        case alias_:
-        mixin (BASIC_TYPE_CASE_RANGE);
-            return false;
-        default:
-            return false;
-        }
+        // h4x
+        auto b = setBookmark();
+        scope(exit) goToBookmark(b);
+        return parseDeclaration() !is null;
+    }
+
+    bool isStatement()
+    {
+        auto b = setBookmark();
+        scope (exit) goToBookmark(b);
+        return parseStatement() !is null;
     }
 
     bool currentIsMemberFunctionAttribute() const
@@ -5223,7 +5505,7 @@ private:
     {
         import std.stdio;
         ++errorCount;
-        if (!suppressMessages)
+        if (suppressMessages <= 0)
         {
             if (errorFunction is null)
                 stderr.writefln("%s(%d:%d): %s", fileName, tokens[index].line,
@@ -5235,10 +5517,10 @@ private:
         while (moreTokens())
         {
             if (currentIsOneOf(TokenType.semicolon, TokenType.rBrace))
-			{
-				advance();
+            {
+                advance();
                 break;
-			}
+            }
             else
                 advance();
         }
@@ -5346,8 +5628,12 @@ private:
             return &tokens[index++];
         else
         {
-            error("Expected " ~ tokenValues[type] ~ " instead of "
-                ~ tokens[index].value);
+            if (tokenValues[type] is null)
+                error("Expected " ~ to!string(type) ~ " instead of "
+                    ~ tokens[index].value);
+            else
+                error("Expected " ~ tokenValues[type] ~ " instead of "
+                    ~ tokens[index].value);
             return null;
         }
     }
@@ -5404,13 +5690,13 @@ private:
 
     size_t setBookmark()
     {
-        suppressMessages = true;
+        ++suppressMessages;
         return index;
     }
 
     void goToBookmark(size_t i)
     {
-        suppressMessages = false;
+        --suppressMessages;
         index = i;
     }
 
@@ -5423,7 +5709,7 @@ private:
         LexerConfig config;
         auto r = byToken(cast(const(ubyte)[]) sourceCode, config);
         Parser p;
-        p.errorFunction = &doNothingErrorFunction;
+        //p.errorFunction = &doNothingErrorFunction;
         p.fileName = testName ~ ".d";
         p.tokens = r.array();
         return p;
@@ -5437,5 +5723,5 @@ private:
     immutable string BASIC_TYPE_CASE_RANGE = q{case bool_: .. case wchar_:};
     immutable string LITERAL_CASE_RANGE = q{case doubleLiteral: .. case wstringLiteral:};
     immutable string SPECIAL_CASE_RANGE = q{case specialDate: .. case specialPrettyFunction:};
-    bool suppressMessages;
+    int suppressMessages;
 }