diff --git a/libdparse b/libdparse
index 4e270c2..ccd0194 160000
--- a/libdparse
+++ b/libdparse
@@ -1 +1 @@
-Subproject commit 4e270c212daf0d2b55843604ecbdd1dcbd399a37
+Subproject commit ccd01946add011c49e5cf92667cca1e1acd2bc33
diff --git a/src/analysis/duplicate_attribute.d b/src/analysis/duplicate_attribute.d
index d91fa81..93c5d47 100644
--- a/src/analysis/duplicate_attribute.d
+++ b/src/analysis/duplicate_attribute.d
@@ -102,27 +102,23 @@ class DuplicateAttributeCheck : BaseAnalyzer
 	{
 		// Get the name from the attribute identifier
 		if (attribute
-			&& attribute.storageClass
-			&& attribute.storageClass.atAttribute
-			&& attribute.storageClass.atAttribute.identifier !is Token.init
-			&& attribute.storageClass.atAttribute.identifier.text
-			&& attribute.storageClass.atAttribute.identifier.text.length)
+			&& attribute.atAttribute
+			&& attribute.atAttribute.identifier !is Token.init
+			&& attribute.atAttribute.identifier.text
+			&& attribute.atAttribute.identifier.text.length)
 		{
-			auto token = attribute.storageClass.atAttribute.identifier;
+			auto token = attribute.atAttribute.identifier;
 			line = token.line;
 			column = token.column;
 			return token.text;
 		}
 
 		// Get the attribute from the storage class token
-		if (attribute
-			&& attribute.storageClass
-			&& attribute.storageClass.token !is Token.init)
+		if (attribute && attribute.attribute.type != tok!"")
 		{
-			auto token = attribute.storageClass.token;
-			line = token.line;
-			column = token.column;
-			return token.type.str;
+			line = attribute.attribute.line;
+			column = attribute.attribute.column;
+			return attribute.attribute.type.str;
 		}
 
 		return null;
diff --git a/src/analysis/enumarrayliteral.d b/src/analysis/enumarrayliteral.d
index 545851a..5d2948b 100644
--- a/src/analysis/enumarrayliteral.d
+++ b/src/analysis/enumarrayliteral.d
@@ -27,23 +27,9 @@ class EnumArrayLiteralCheck : BaseAnalyzer
 	mixin visitTemplate!UnionDeclaration;
 	mixin visitTemplate!StructDeclaration;
 
-	override void visit(const Declaration dec)
-	{
-		if (inAggregate) foreach (attr; dec.attributes)
-		{
-			if (attr.storageClass !is null &&
-				attr.storageClass.token == tok!"enum")
-			{
-				looking = true;
-			}
-		}
-		dec.accept(this);
-		looking = false;
-	}
-
 	override void visit(const AutoDeclaration autoDec)
 	{
-		if (looking)
+		if (autoDec.storageClass && autoDec.storageClass.token == tok!"enum")
 		{
 			foreach (i, initializer; autoDec.initializers)
 			{
diff --git a/src/analysis/function_attributes.d b/src/analysis/function_attributes.d
index 62d1bb5..3ddcfeb 100644
--- a/src/analysis/function_attributes.d
+++ b/src/analysis/function_attributes.d
@@ -48,11 +48,10 @@ class FunctionAttributeCheck : BaseAnalyzer
 
 	override void visit(const AttributeDeclaration dec)
 	{
-		if (inInterface > 0 && dec.attribute.storageClass !is null
-			&& dec.attribute.storageClass.token == tok!"abstract")
+		if (inInterface > 0 && dec.attribute.attribute == tok!"abstract")
 		{
-			addErrorMessage(dec.attribute.storageClass.token.line,
-				dec.attribute.storageClass.token.column, KEY, ABSTRACT_MESSAGE);
+			addErrorMessage(dec.attribute.attribute.line,
+				dec.attribute.attribute.column, KEY, ABSTRACT_MESSAGE);
 		}
 	}
 
@@ -62,21 +61,21 @@ class FunctionAttributeCheck : BaseAnalyzer
 			goto end;
 		foreach (attr; dec.attributes)
 		{
-			if (attr.storageClass is null)
+			if (attr.attribute.type == tok!"")
 				continue;
-			if (attr.storageClass.token == tok!"abstract" && inInterface)
+			if (attr.attribute == tok!"abstract" && inInterface)
 			{
-				addErrorMessage(attr.storageClass.token.line,
-					attr.storageClass.token.column, KEY, ABSTRACT_MESSAGE);
+				addErrorMessage(attr.attribute.line,
+					attr.attribute.column, KEY, ABSTRACT_MESSAGE);
 				continue;
 			}
 			if (dec.functionDeclaration !is null
-				&& (attr.storageClass.token == tok!"const"
-				|| attr.storageClass.token == tok!"inout"
-				|| attr.storageClass.token == tok!"immutable"))
+				&& (attr.attribute == tok!"const"
+				|| attr.attribute == tok!"inout"
+				|| attr.attribute == tok!"immutable"))
 			{
 				import std.string : format;
-				immutable string attrString = str(attr.storageClass.token.type);
+				immutable string attrString = str(attr.attribute.type);
 				addErrorMessage(dec.functionDeclaration.name.line,
 					dec.functionDeclaration.name.column, KEY,
 					format("'%s' is not an attribute of the return type."
diff --git a/src/analysis/local_imports.d b/src/analysis/local_imports.d
index 5b04318..71ecb50 100644
--- a/src/analysis/local_imports.d
+++ b/src/analysis/local_imports.d
@@ -36,7 +36,7 @@ class LocalImportCheck : BaseAnalyzer
 		}
 		foreach (attr; dec.attributes)
 		{
-			if (attr.storageClass !is null && attr.storageClass.token == tok!"static")
+			if (attr.attribute == tok!"static")
 				isStatic = true;
 		}
 		dec.accept(this);
diff --git a/src/analysis/objectconst.d b/src/analysis/objectconst.d
index cdb8c2d..f46d1a6 100644
--- a/src/analysis/objectconst.d
+++ b/src/analysis/objectconst.d
@@ -46,14 +46,13 @@ class ObjectConstCheck : BaseAnalyzer
 
 	private static bool hasConst(const Attribute[] attributes)
 	{
-		import std.algorithm;
-		return attributes.any!(a => a.attribute == tok!"const"
-			|| (a.storageClass !is null && a.storageClass.token == tok!"const"));
+		import std.algorithm : any;
+		return attributes.any!(a => a.attribute == tok!"const");
 	}
 
 	private static bool hasConst(const MemberFunctionAttribute[] attributes)
 	{
-		import std.algorithm;
+		import std.algorithm : any;
 		return attributes.any!(a => a.tokenType == tok!"const"
 			|| a.tokenType == tok!"immutable"
 			|| a.tokenType == tok!"inout");
@@ -71,7 +70,7 @@ class ObjectConstCheck : BaseAnalyzer
 
 unittest
 {
-	import analysis.config;
+	import analysis.config : StaticAnalysisConfig;
 	StaticAnalysisConfig sac;
 	sac.object_const_check = true;
 	assertAnalyzerWarnings(q{
diff --git a/src/analysis/run.d b/src/analysis/run.d
index 7963f67..7404934 100644
--- a/src/analysis/run.d
+++ b/src/analysis/run.d
@@ -69,10 +69,10 @@ void writeJSON(string key, string fileName, size_t line, size_t column, string m
 	write(  "    }");
 }
 
-void syntaxCheck(string[] fileNames)
+bool syntaxCheck(string[] fileNames)
 {
 	StaticAnalysisConfig config = defaultStaticAnalysisConfig();
-	analyze(fileNames, config, false);
+	return analyze(fileNames, config, false);
 }
 
 void generateReport(string[] fileNames, const StaticAnalysisConfig config)
@@ -112,8 +112,10 @@ void generateReport(string[] fileNames, const StaticAnalysisConfig config)
 }
 
 // For multiple files
-void analyze(string[] fileNames, const StaticAnalysisConfig config, bool staticAnalyze = true)
+// Returns: true if there were errors
+bool analyze(string[] fileNames, const StaticAnalysisConfig config, bool staticAnalyze = true)
 {
+	bool hasErrors = false;
 	foreach (fileName; fileNames)
 	{
 		File f = File(fileName);
@@ -122,7 +124,12 @@ void analyze(string[] fileNames, const StaticAnalysisConfig config, bool staticA
 		f.rawRead(code);
 		ParseAllocator p = new ParseAllocator;
 		StringCache cache = StringCache(StringCache.defaultBucketCount);
-		const Module m = parseModule(fileName, code, p, cache, false);
+		uint errorCount = 0;
+		const Module m = parseModule(fileName, code, p, cache, false, null,
+			&errorCount, null);
+		assert (m);
+		if (errorCount > 0)
+			hasErrors = true;
 		MessageSet results = analyze(fileName, m, config, staticAnalyze);
 		if (results is null)
 			continue;
@@ -130,10 +137,12 @@ void analyze(string[] fileNames, const StaticAnalysisConfig config, bool staticA
 			writefln("%s(%d:%d)[warn]: %s", result.fileName, result.line,
 				result.column, result.message);
 	}
+	return hasErrors;
 }
 
 const(Module) parseModule(string fileName, ubyte[] code, ParseAllocator p,
-	ref StringCache cache, bool report, ulong* linesOfCode = null)
+	ref StringCache cache, bool report, ulong* linesOfCode = null,
+	uint* errorCount = null, uint* warningCount = null)
 {
 	import stats : isLineOfCode;
 	auto lexer = byToken(code);
@@ -153,7 +162,8 @@ const(Module) parseModule(string fileName, ubyte[] code, ParseAllocator p,
 				message.isError);
 	}
 	return std.d.parser.parseModule(tokens, fileName, p,
-		report ? &messageFunctionJSON : &messageFunction);
+		report ? &messageFunctionJSON : &messageFunction,
+		errorCount, warningCount);
 }
 
 MessageSet analyze(string fileName, const Module m,
diff --git a/src/analysis/undocumented.d b/src/analysis/undocumented.d
index ad40349..c1273f4 100644
--- a/src/analysis/undocumented.d
+++ b/src/analysis/undocumented.d
@@ -35,10 +35,9 @@ class UndocumentedDeclarationCheck : BaseAnalyzer
 		if (dec.attributeDeclaration)
 		{
 			auto attr = dec.attributeDeclaration.attribute;
-			if (isProtection(attr.attribute))
-				set(attr.attribute);
-			else if (dec.attributeDeclaration.attribute.storageClass !is null
-				&& dec.attributeDeclaration.attribute.storageClass.token == tok!"override")
+			if (isProtection(attr.attribute.type))
+				set(attr.attribute.type);
+			else if (attr.attribute == tok!"override")
 			{
 				setOverride(true);
 			}
@@ -50,16 +49,13 @@ class UndocumentedDeclarationCheck : BaseAnalyzer
 			bool ovr = false;
 			foreach (attribute; dec.attributes)
 			{
-				if (isProtection(attribute.attribute))
+				if (isProtection(attribute.attribute.type))
 				{
 					shouldPop = true;
-					push(attribute.attribute);
+					push(attribute.attribute.type);
 				}
-				else if (attribute.storageClass !is null
-					&& attribute.storageClass.token == tok!"override")
-				{
+				else if (attribute.attribute == tok!"override")
 					ovr = true;
-				}
 			}
 			if (ovr)
 				setOverride(true);
diff --git a/src/analysis/unused.d b/src/analysis/unused.d
index 6ae42f0..ea86c31 100644
--- a/src/analysis/unused.d
+++ b/src/analysis/unused.d
@@ -34,8 +34,7 @@ class UnusedVariableCheck : BaseAnalyzer
 	override void visit(const Declaration declaration)
 	{
 		if (!isOverride) foreach (attribute; declaration.attributes)
-			isOverride = isOverride || (attribute.storageClass !is null &&
-				attribute.storageClass.token == tok!"override");
+			isOverride = isOverride || (attribute.attribute == tok!"override");
 		declaration.accept(this);
 		isOverride = false;
 	}
diff --git a/src/astprinter.d b/src/astprinter.d
index 4f12a97..77bdac7 100644
--- a/src/astprinter.d
+++ b/src/astprinter.d
@@ -12,1107 +12,1081 @@ import std.array;
 
 template tagAndAccept(string tagName)
 {
-	immutable tagAndAccept = `output.writeln("<` ~ tagName ~ `>");`
-		~ tagName ~ `.accept(this);`
-		~ `output.writeln("</` ~ tagName ~ `>");`;
+    immutable tagAndAccept = `output.writeln("<` ~ tagName ~ `>");`
+        ~ tagName ~ `.accept(this);`
+        ~ `output.writeln("</` ~ tagName ~ `>");`;
 }
 
 class XMLPrinter : ASTVisitor
 {
-	override void visit(const AddExpression addExpression)
-	{
-		output.writeln("<addExpression operator=\"", str(addExpression.operator) ,"\">");
-		output.writeln("<left>");
-		visit(addExpression.left);
-		output.writeln("</left>");
-		if (addExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(addExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</addExpression>");
-	}
+    override void visit(const AddExpression addExpression)
+    {
+        output.writeln("<addExpression operator=\"", str(addExpression.operator) ,"\">");
+        output.writeln("<left>");
+        visit(addExpression.left);
+        output.writeln("</left>");
+        if (addExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(addExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</addExpression>");
+    }
 
-	override void visit(const AliasDeclaration aliasDeclaration)
-	{
-		output.writeln("<aliasDeclaration>");
-		writeDdoc(aliasDeclaration.comment);
-		aliasDeclaration.accept(this);
-		output.writeln("</aliasDeclaration>");
-	}
+    override void visit(const AliasDeclaration aliasDeclaration)
+    {
+        output.writeln("<aliasDeclaration>");
+        writeDdoc(aliasDeclaration.comment);
+        aliasDeclaration.accept(this);
+        output.writeln("</aliasDeclaration>");
+    }
 
-	override void visit(const AlignAttribute alignAttribute)
-	{
-		output.writeln("<alignAttribute align=\"", alignAttribute.intLiteral.text, "\">");
-	}
+    override void visit(const AlignAttribute alignAttribute)
+    {
+        output.writeln("<alignAttribute align=\"", alignAttribute.intLiteral.text, "\">");
+    }
 
-	override void visit(const AndAndExpression andAndExpression)
-	{
-		output.writeln("<andAndExpression>");
-		output.writeln("<left>");
-		visit(andAndExpression.left);
-		output.writeln("</left>");
-		if (andAndExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(andAndExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</andAndExpression>");
-	}
+    override void visit(const AndAndExpression andAndExpression)
+    {
+        output.writeln("<andAndExpression>");
+        output.writeln("<left>");
+        visit(andAndExpression.left);
+        output.writeln("</left>");
+        if (andAndExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(andAndExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</andAndExpression>");
+    }
 
-	override void visit(const AndExpression andExpression)
-	{
-		output.writeln("<andExpression>");
-		output.writeln("<left>");
-		visit(andExpression.left);
-		output.writeln("</left>");
-		if (andExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(andExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</andExpression>");
-	}
+    override void visit(const AndExpression andExpression)
+    {
+        output.writeln("<andExpression>");
+        output.writeln("<left>");
+        visit(andExpression.left);
+        output.writeln("</left>");
+        if (andExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(andExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</andExpression>");
+    }
 
-	override void visit(const AsmInstruction asmInstruction)
-	{
-		output.writeln("<asmInstruction>");
-		if (asmInstruction.hasAlign)
-		{
-			output.writeln("<align>");
-			visit(asmInstruction.identifierOrIntegerOrOpcode);
-			output.writeln("</align>");
-		}
-		if (asmInstruction.asmInstruction !is null)
-		{
-			output.writeln("<label label=\"", asmInstruction.identifierOrIntegerOrOpcode.text, "\"/>");
-			asmInstruction.asmInstruction.accept(this);
-		}
-		else if (asmInstruction.identifierOrIntegerOrOpcode != tok!"")
-			visit(asmInstruction.identifierOrIntegerOrOpcode);
-		if (asmInstruction.operands !is null)
-		{
-			stderr.writeln("operands is not null");
-			visit(asmInstruction.operands);
-		}
-		output.writeln("</asmInstruction>");
-	}
+    override void visit(const AsmInstruction asmInstruction)
+    {
+        output.writeln("<asmInstruction>");
+        if (asmInstruction.hasAlign)
+        {
+            output.writeln("<align>");
+            visit(asmInstruction.identifierOrIntegerOrOpcode);
+            output.writeln("</align>");
+        }
+        if (asmInstruction.asmInstruction !is null)
+        {
+            output.writeln("<label label=\"", asmInstruction.identifierOrIntegerOrOpcode.text, "\"/>");
+            asmInstruction.asmInstruction.accept(this);
+        }
+        else if (asmInstruction.identifierOrIntegerOrOpcode != tok!"")
+            visit(asmInstruction.identifierOrIntegerOrOpcode);
+        if (asmInstruction.operands !is null)
+        {
+            stderr.writeln("operands is not null");
+            visit(asmInstruction.operands);
+        }
+        output.writeln("</asmInstruction>");
+    }
 
-	override void visit(const AssertExpression assertExpression)
-	{
-		output.writeln("<assertExpression>");
-		output.writeln("<assertion>");
-		assertExpression.assertion.accept(this);
-		output.writeln("</assertion>");
-		if (assertExpression.message !is null)
-		{
-			output.writeln("<message>");
-			assertExpression.message.accept(this);
-			output.writeln("</message>");
-		}
-		output.writeln("</assertExpression>");
-	}
+    override void visit(const AssertExpression assertExpression)
+    {
+        output.writeln("<assertExpression>");
+        output.writeln("<assertion>");
+        assertExpression.assertion.accept(this);
+        output.writeln("</assertion>");
+        if (assertExpression.message !is null)
+        {
+            output.writeln("<message>");
+            assertExpression.message.accept(this);
+            output.writeln("</message>");
+        }
+        output.writeln("</assertExpression>");
+    }
 
-	override void visit(const AssignExpression assignExpression)
-	{
-		if (assignExpression.assignExpression is null)
-			output.writeln("<assignExpression>");
-		else
-			output.writeln("<assignExpression operator=\"",
-				xmlAttributeEscape(str(assignExpression.operator)), "\">");
-		assignExpression.accept(this);
-		output.writeln("</assignExpression>");
-	}
+    override void visit(const AssignExpression assignExpression)
+    {
+        if (assignExpression.assignExpression is null)
+            output.writeln("<assignExpression>");
+        else
+            output.writeln("<assignExpression operator=\"",
+                xmlAttributeEscape(str(assignExpression.operator)), "\">");
+        assignExpression.accept(this);
+        output.writeln("</assignExpression>");
+    }
 
-	override void visit(const AtAttribute atAttribute)
-	{
-		output.writeln("<atAttribute>");
-		if (atAttribute.identifier.type == tok!"")
-			atAttribute.accept(this);
-		else
-			output.writeln("<identifier>", atAttribute.identifier.text, "</identifier>");
-		output.writeln("</atAttribute>");
-	}
+    override void visit(const AtAttribute atAttribute)
+    {
+        output.writeln("<atAttribute>");
+        if (atAttribute.identifier.type == tok!"")
+            atAttribute.accept(this);
+        else
+            output.writeln("<identifier>", atAttribute.identifier.text, "</identifier>");
+        output.writeln("</atAttribute>");
+    }
 
-	override void visit(const Attribute attribute)
-	{
-		output.writeln("<attribute>");
-		if (attribute.attribute == tok!"")
-			attribute.accept(this);
-		else
-			output.writeln(str(attribute.attribute));
-		output.writeln("</attribute>");
-	}
+    override void visit(const Attribute attribute)
+    {
+        output.writeln("<attribute>");
+        if (attribute.attribute == tok!"")
+            attribute.accept(this);
+        else
+            output.writeln(str(attribute.attribute.type));
+        output.writeln("</attribute>");
+    }
 
-	override void visit(const AutoDeclaration autoDec)
-	{
-		output.writeln("<autoDeclaration>");
-		for (size_t i = 0; i < autoDec.identifiers.length; i++)
-		{
-			output.writeln("<item>");
-			output.writeln("<name line=\"", autoDec.identifiers[i].line, "\">",
-				autoDec.identifiers[i].text, "</name>");
-			visit(autoDec.initializers[i]);
-			output.writeln("</item>");
-		}
-		output.writeln("</autoDeclaration>");
-	}
+    override void visit(const AutoDeclaration autoDec)
+    {
+        output.writeln("<autoDeclaration>");
+        for (size_t i = 0; i < autoDec.identifiers.length; i++)
+        {
+            output.writeln("<item>");
+            output.writeln("<name line=\"", autoDec.identifiers[i].line, "\">",
+                autoDec.identifiers[i].text, "</name>");
+            visit(autoDec.initializers[i]);
+            output.writeln("</item>");
+        }
+        output.writeln("</autoDeclaration>");
+    }
 
-	override void visit(const BreakStatement breakStatement)
-	{
-		if (breakStatement.label.type == tok!"")
-			output.writeln("<breakStatement/>");
-		else
-			output.writeln("<breakStatement label=\"", breakStatement.label.text, "\"/>");
-	}
+    override void visit(const BreakStatement breakStatement)
+    {
+        if (breakStatement.label.type == tok!"")
+            output.writeln("<breakStatement/>");
+        else
+            output.writeln("<breakStatement label=\"", breakStatement.label.text, "\"/>");
+    }
 
-	override void visit(const CaseRangeStatement caseRangeStatement)
-	{
-		output.writeln("<caseRangeStatement>");
-		if (caseRangeStatement.low !is null)
-		{
-			output.writeln("<low>");
-			visit(caseRangeStatement.low);
-			output.writeln("</low>");
-		}
-		if (caseRangeStatement.high !is null)
-		{
-			output.writeln("<high>");
-			visit(caseRangeStatement.high);
-			output.writeln("</high>");
-		}
-		if (caseRangeStatement.declarationsAndStatements !is null)
-			visit(caseRangeStatement.declarationsAndStatements);
-		output.writeln("</caseRangeStatement>");
-	}
+    override void visit(const CaseRangeStatement caseRangeStatement)
+    {
+        output.writeln("<caseRangeStatement>");
+        if (caseRangeStatement.low !is null)
+        {
+            output.writeln("<low>");
+            visit(caseRangeStatement.low);
+            output.writeln("</low>");
+        }
+        if (caseRangeStatement.high !is null)
+        {
+            output.writeln("<high>");
+            visit(caseRangeStatement.high);
+            output.writeln("</high>");
+        }
+        if (caseRangeStatement.declarationsAndStatements !is null)
+            visit(caseRangeStatement.declarationsAndStatements);
+        output.writeln("</caseRangeStatement>");
+    }
 
-	override void visit(const Catch catch_)
-	{
-		output.writeln("<catch>");
-		catch_.accept(this);
-		output.writeln("</catch>");
-	}
+    override void visit(const Catch catch_)
+    {
+        output.writeln("<catch>");
+        catch_.accept(this);
+        output.writeln("</catch>");
+    }
 
-	override void visit(const ClassDeclaration classDec)
-	{
-		output.writeln("<classDeclaration line=\"", classDec.name.line, "\">");
-		output.writeln("<name>", classDec.name.text, "</name>");
-		writeDdoc(classDec.comment);
-		classDec.accept(this);
-		output.writeln("</classDeclaration>");
-	}
+    override void visit(const ClassDeclaration classDec)
+    {
+        output.writeln("<classDeclaration line=\"", classDec.name.line, "\">");
+        output.writeln("<name>", classDec.name.text, "</name>");
+        writeDdoc(classDec.comment);
+        classDec.accept(this);
+        output.writeln("</classDeclaration>");
+    }
 
-	override void visit(const ConditionalDeclaration conditionalDeclaration)
-	{
-		output.writeln("<conditionalDeclaration>");
-		visit(conditionalDeclaration.compileCondition);
-		output.writeln("<trueDeclarations>");
-		foreach (dec; conditionalDeclaration.trueDeclarations)
-			visit(dec);
-		output.writeln("</trueDeclarations>");
-		if (conditionalDeclaration.falseDeclaration !is null)
-		{
-			output.writeln("<falseDeclaration>");
-			visit(conditionalDeclaration.falseDeclaration);
-			output.writeln("</falseDeclaration>");
-		}
-		output.writeln("</conditionalDeclaration>");
-	}
+    override void visit(const ConditionalDeclaration conditionalDeclaration)
+    {
+        output.writeln("<conditionalDeclaration>");
+        visit(conditionalDeclaration.compileCondition);
+        output.writeln("<trueDeclarations>");
+        foreach (dec; conditionalDeclaration.trueDeclarations)
+            visit(dec);
+        output.writeln("</trueDeclarations>");
+        if (conditionalDeclaration.falseDeclaration !is null)
+        {
+            output.writeln("<falseDeclaration>");
+            visit(conditionalDeclaration.falseDeclaration);
+            output.writeln("</falseDeclaration>");
+        }
+        output.writeln("</conditionalDeclaration>");
+    }
 
-	override void visit(const ConditionalStatement conditionalStatement)
-	{
-		output.writeln("<conditionalStatement>");
-		visit(conditionalStatement.compileCondition);
-		output.writeln("<trueStatement>");
-		visit(conditionalStatement.trueStatement);
-		output.writeln("</trueStatement>");
-		if (conditionalStatement.falseStatement !is null)
-		{
-			output.writeln("<falseStatement>");
-			visit(conditionalStatement.falseStatement);
-			output.writeln("</falseStatement>");
-		}
-		output.writeln("</conditionalStatement>");
-	}
+    override void visit(const ConditionalStatement conditionalStatement)
+    {
+        output.writeln("<conditionalStatement>");
+        visit(conditionalStatement.compileCondition);
+        output.writeln("<trueStatement>");
+        visit(conditionalStatement.trueStatement);
+        output.writeln("</trueStatement>");
+        if (conditionalStatement.falseStatement !is null)
+        {
+            output.writeln("<falseStatement>");
+            visit(conditionalStatement.falseStatement);
+            output.writeln("</falseStatement>");
+        }
+        output.writeln("</conditionalStatement>");
+    }
 
-	override void visit(const ContinueStatement continueStatement)
-	{
-		if (continueStatement.label.type == tok!"")
-			output.writeln("<continueStatement/>");
-		else
-			output.writeln("<continueStatement label=\"",
-				continueStatement.label.text, "\"/>");
-	}
+    override void visit(const ContinueStatement continueStatement)
+    {
+        if (continueStatement.label.type == tok!"")
+            output.writeln("<continueStatement/>");
+        else
+            output.writeln("<continueStatement label=\"",
+                continueStatement.label.text, "\"/>");
+    }
 
-	override void visit(const DebugCondition debugCondition)
-	{
-		if (debugCondition.identifierOrInteger.type == tok!"")
-			output.writeln("<debugCondition/>");
-		else
-			output.writeln("<debugCondition condition=\"",
-				debugCondition.identifierOrInteger.text, "\"/>");
-	}
+    override void visit(const DebugCondition debugCondition)
+    {
+        if (debugCondition.identifierOrInteger.type == tok!"")
+            output.writeln("<debugCondition/>");
+        else
+            output.writeln("<debugCondition condition=\"",
+                debugCondition.identifierOrInteger.text, "\"/>");
+    }
 
-	override void visit(const DebugSpecification debugSpecification)
-	{
-		if (debugSpecification.identifierOrInteger.type == tok!"")
-			output.writeln("<debugSpecification/>");
-		else
-			output.writeln("<debugSpecification condition=\"",
-				debugSpecification.identifierOrInteger.text, "\"/>");
-	}
+    override void visit(const DebugSpecification debugSpecification)
+    {
+        if (debugSpecification.identifierOrInteger.type == tok!"")
+            output.writeln("<debugSpecification/>");
+        else
+            output.writeln("<debugSpecification condition=\"",
+                debugSpecification.identifierOrInteger.text, "\"/>");
+    }
 
-	override void visit(const Declarator declarator)
-	{
-		output.writeln("<declarator line=\"", declarator.name.line, "\">");
-		output.writeln("<name>", declarator.name.text, "</name>");
-		writeDdoc(declarator.comment);
-		declarator.accept(this);
-		output.writeln("</declarator>");
-	}
+    override void visit(const Declarator declarator)
+    {
+        output.writeln("<declarator line=\"", declarator.name.line, "\">");
+        output.writeln("<name>", declarator.name.text, "</name>");
+        writeDdoc(declarator.comment);
+        declarator.accept(this);
+        output.writeln("</declarator>");
+    }
 
-	override void visit(const Deprecated deprecated_)
-	{
-		if (deprecated_.assignExpression !is null)
-		{
-			output.writeln("<deprecated>");
-			deprecated_.accept(this);
-			output.writeln("</deprecated>");
-		}
-		else
-			output.writeln("<deprecated/>");
-	}
+    override void visit(const Deprecated deprecated_)
+    {
+        if (deprecated_.stringLiteral.type != tok!"")
+            output.writeln("<deprecated>", deprecated_.stringLiteral.text, "</deprecated>");
+        else
+            output.writeln("<deprecated/>");
+    }
 
-	override void visit(const EnumDeclaration enumDec)
-	{
-		output.writeln("<enumDeclaration line=\"", enumDec.name.line, "\">");
+    override void visit(const EnumDeclaration enumDec)
+    {
+        output.writeln("<enumDeclaration line=\"", enumDec.name.line, "\">");
         writeDdoc(enumDec.comment);
-		if (enumDec.name.type == tok!"identifier")
-			output.writeln("<name>", enumDec.name.text, "</name>");
-		enumDec.accept(this);
-		output.writeln("</enumDeclaration>");
-	}
+        if (enumDec.name.type == tok!"identifier")
+            output.writeln("<name>", enumDec.name.text, "</name>");
+        enumDec.accept(this);
+        output.writeln("</enumDeclaration>");
+    }
 
-	override void visit(const EnumMember enumMem)
-	{
-		output.writeln("<enumMember line=\"", enumMem.name.line, "\">");
+    override void visit(const EnumMember enumMem)
+    {
+        output.writeln("<enumMember line=\"", enumMem.name.line, "\">");
         writeDdoc(enumMem.comment);
-		enumMem.accept(this);
-		output.writeln("</enumMember>");
-	}
+        enumMem.accept(this);
+        output.writeln("</enumMember>");
+    }
 
-	override void visit(const EqualExpression equalExpression)
-	{
-		output.writeln("<equalExpression operator=\"", str(equalExpression.operator), "\">");
-		output.writeln("<left>");
-		visit(equalExpression.left);
-		output.writeln("</left>");
-		output.writeln("<right>");
-		visit(equalExpression.right);
-		output.writeln("</right>");
-		output.writeln("</equalExpression>");
-	}
+    override void visit(const EqualExpression equalExpression)
+    {
+        output.writeln("<equalExpression operator=\"", str(equalExpression.operator), "\">");
+        output.writeln("<left>");
+        visit(equalExpression.left);
+        output.writeln("</left>");
+        output.writeln("<right>");
+        visit(equalExpression.right);
+        output.writeln("</right>");
+        output.writeln("</equalExpression>");
+    }
 
-	override void visit(const Finally finally_)
-	{
-		output.writeln("<finally>");
-		finally_.accept(this);
-		output.writeln("</finally>");
-	}
+    override void visit(const Finally finally_)
+    {
+        output.writeln("<finally>");
+        finally_.accept(this);
+        output.writeln("</finally>");
+    }
 
-	override void visit(const ForStatement forStatement)
-	{
-		output.writeln("<forStatement>");
-		if (forStatement.initialization !is null)
-		{
-			output.writeln("<initialization>");
-			visit(forStatement.initialization);
-			output.writeln("</initialization>");
-		}
-		if (forStatement.test !is null)
-		{
-			output.writeln("<test>");
-			visit(forStatement.test);
-			output.writeln("</test>");
-		}
-		if (forStatement.increment !is null)
-		{
-			output.writeln("<increment>");
-			visit(forStatement.increment);
-			output.writeln("</increment>");
-		}
-		if (forStatement.declarationOrStatement !is null)
-			visit(forStatement.declarationOrStatement);
-		output.writeln("</forStatement>");
-	}
+    override void visit(const ForStatement forStatement)
+    {
+        output.writeln("<forStatement>");
+        if (forStatement.initialization !is null)
+        {
+            output.writeln("<initialization>");
+            visit(forStatement.initialization);
+            output.writeln("</initialization>");
+        }
+        if (forStatement.test !is null)
+        {
+            output.writeln("<test>");
+            visit(forStatement.test);
+            output.writeln("</test>");
+        }
+        if (forStatement.increment !is null)
+        {
+            output.writeln("<increment>");
+            visit(forStatement.increment);
+            output.writeln("</increment>");
+        }
+        if (forStatement.declarationOrStatement !is null)
+            visit(forStatement.declarationOrStatement);
+        output.writeln("</forStatement>");
+    }
 
-	override void visit(const ForeachStatement foreachStatement)
-	{
-		output.writeln("<foreachStatement type=\"", str(
-			foreachStatement.type), "\">");
-		if (foreachStatement.foreachType !is null)
-			visit(foreachStatement.foreachType);
-		if (foreachStatement.foreachTypeList !is null)
-			visit(foreachStatement.foreachTypeList);
-		output.writeln("<low>");
-		visit(foreachStatement.low);
-		output.writeln("</low>");
-		if (foreachStatement.high !is null)
-		{
-			output.writeln("<high>");
-			visit(foreachStatement.high);
-			output.writeln("</high>");
-		}
-		visit(foreachStatement.declarationOrStatement);
-		output.writeln("</foreachStatement>");
-	}
+    override void visit(const ForeachStatement foreachStatement)
+    {
+        output.writeln("<foreachStatement type=\"", str(
+            foreachStatement.type), "\">");
+        if (foreachStatement.foreachType !is null)
+            visit(foreachStatement.foreachType);
+        if (foreachStatement.foreachTypeList !is null)
+            visit(foreachStatement.foreachTypeList);
+        output.writeln("<low>");
+        visit(foreachStatement.low);
+        output.writeln("</low>");
+        if (foreachStatement.high !is null)
+        {
+            output.writeln("<high>");
+            visit(foreachStatement.high);
+            output.writeln("</high>");
+        }
+        visit(foreachStatement.declarationOrStatement);
+        output.writeln("</foreachStatement>");
+    }
 
-	override void visit(const ForeachType foreachType)
-	{
-		output.writeln("<foreachType>");
-		foreach (constructor; foreachType.typeConstructors)
-		{
-			output.writeln("<typeConstructor>", str(constructor), "</typeConstructor>");
-		}
-		if (foreachType.type !is null)
-			visit(foreachType.type);
-		visit(foreachType.identifier);
-		output.writeln("</foreachType>");
+    override void visit(const ForeachType foreachType)
+    {
+        output.writeln("<foreachType>");
+        foreach (constructor; foreachType.typeConstructors)
+        {
+            output.writeln("<typeConstructor>", str(constructor), "</typeConstructor>");
+        }
+        if (foreachType.type !is null)
+            visit(foreachType.type);
+        visit(foreachType.identifier);
+        output.writeln("</foreachType>");
 
-	}
+    }
 
-	override void visit(const FunctionDeclaration functionDec)
-	{
-		output.writeln("<functionDeclaration line=\"", functionDec.name.line, "\">");
-		output.writeln("<name>", functionDec.name.text, "</name>");
+    override void visit(const FunctionDeclaration functionDec)
+    {
+        output.writeln("<functionDeclaration line=\"", functionDec.name.line, "\">");
+        output.writeln("<name>", functionDec.name.text, "</name>");
         writeDdoc(functionDec.comment);
-		if (functionDec.hasAuto)
-			output.writeln("<auto/>");
-		if (functionDec.hasRef)
-			output.writeln("<ref/>");
-		functionDec.accept(this);
-		output.writeln("</functionDeclaration>");
-	}
+        if (functionDec.hasAuto)
+            output.writeln("<auto/>");
+        if (functionDec.hasRef)
+            output.writeln("<ref/>");
+        functionDec.accept(this);
+        output.writeln("</functionDeclaration>");
+    }
 
-	override void visit(const FunctionLiteralExpression functionLiteralExpression)
-	{
-		output.writeln("<functionLiteralExpression type=\"",
-			functionLiteralExpression.functionOrDelegate != tok!""
-				? str(functionLiteralExpression.functionOrDelegate)
-				: "auto", "\">");
-		functionLiteralExpression.accept(this);
-		output.writeln("</functionLiteralExpression>");
-	}
+    override void visit(const FunctionLiteralExpression functionLiteralExpression)
+    {
+        output.writeln("<functionLiteralExpression type=\"",
+            functionLiteralExpression.functionOrDelegate != tok!""
+                ? str(functionLiteralExpression.functionOrDelegate)
+                : "auto", "\">");
+        functionLiteralExpression.accept(this);
+        output.writeln("</functionLiteralExpression>");
+    }
 
-	override void visit(const GotoStatement gotoStatement)
-	{
-		if (gotoStatement.label.type == tok!"default")
-			output.writeln("<gotoStatement default=\"true\"/>");
-		else if (gotoStatement.label.type == tok!"identifier")
-			output.writeln("<gotoStatement label=\"", gotoStatement.label.text, "\"/>");
-		else
-		{
-			output.writeln("<gotoStatement>");
-			output.writeln("<case>");
-			if (gotoStatement.expression)
-				visit(gotoStatement.expression);
-			output.writeln("</case>");
-			output.writeln("</gotoStatement>");
-		}
-	}
+    override void visit(const GotoStatement gotoStatement)
+    {
+        if (gotoStatement.label.type == tok!"default")
+            output.writeln("<gotoStatement default=\"true\"/>");
+        else if (gotoStatement.label.type == tok!"identifier")
+            output.writeln("<gotoStatement label=\"", gotoStatement.label.text, "\"/>");
+        else
+        {
+            output.writeln("<gotoStatement>");
+            output.writeln("<case>");
+            if (gotoStatement.expression)
+                visit(gotoStatement.expression);
+            output.writeln("</case>");
+            output.writeln("</gotoStatement>");
+        }
+    }
 
-	override void visit(const IdentityExpression identityExpression)
-	{
-		if (identityExpression.negated)
-			output.writeln("<identityExpression operator=\"!is\">");
-		else
-			output.writeln("<identityExpression operator=\"is\">");
-		output.writeln("<left>");
-		visit(identityExpression.left);
-		output.writeln("</left>");
-		output.writeln("<right>");
-		visit(identityExpression.right);
-		output.writeln("</right>");
-		output.writeln("</identityExpression>");
-	}
+    override void visit(const IdentityExpression identityExpression)
+    {
+        if (identityExpression.negated)
+            output.writeln("<identityExpression operator=\"!is\">");
+        else
+            output.writeln("<identityExpression operator=\"is\">");
+        output.writeln("<left>");
+        visit(identityExpression.left);
+        output.writeln("</left>");
+        output.writeln("<right>");
+        visit(identityExpression.right);
+        output.writeln("</right>");
+        output.writeln("</identityExpression>");
+    }
 
-	override void visit(const IfStatement ifStatement)
-	{
-		output.writeln("<ifStatement>");
+    override void visit(const IfStatement ifStatement)
+    {
+        output.writeln("<ifStatement>");
 
-		output.writeln("<condition>");
-		if (ifStatement.identifier.type != tok!"")
-		{
-			if (ifStatement.type is null)
-				output.writeln("<auto/>");
-			else
-				visit(ifStatement.type);
-			visit(ifStatement.identifier);
-		}
-		ifStatement.expression.accept(this);
-		output.writeln("</condition>");
+        output.writeln("<condition>");
+        if (ifStatement.identifier.type != tok!"")
+        {
+            if (ifStatement.type is null)
+                output.writeln("<auto/>");
+            else
+                visit(ifStatement.type);
+            visit(ifStatement.identifier);
+        }
+        ifStatement.expression.accept(this);
+        output.writeln("</condition>");
 
-		output.writeln("<then>");
-		ifStatement.thenStatement.accept(this);
-		output.writeln("</then>");
+        output.writeln("<then>");
+        ifStatement.thenStatement.accept(this);
+        output.writeln("</then>");
 
-		if (ifStatement.elseStatement !is null)
-		{
-			output.writeln("<else>");
-			ifStatement.elseStatement.accept(this);
-			output.writeln("</else>");
-		}
-		output.writeln("</ifStatement>");
-	}
+        if (ifStatement.elseStatement !is null)
+        {
+            output.writeln("<else>");
+            ifStatement.elseStatement.accept(this);
+            output.writeln("</else>");
+        }
+        output.writeln("</ifStatement>");
+    }
 
-	override void visit(const ImportBind importBind)
-	{
-		if (importBind.right.type == tok!"")
-			output.writeln("<importBind symbol=\"", importBind.left.text, "\"/>");
-		else
-			output.writeln("<importBind symbol=\"", importBind.right.text,
-				"\" rename=\"", importBind.left.text, "\"/>");
-	}
+    override void visit(const ImportBind importBind)
+    {
+        if (importBind.right.type == tok!"")
+            output.writeln("<importBind symbol=\"", importBind.left.text, "\"/>");
+        else
+            output.writeln("<importBind symbol=\"", importBind.right.text,
+                "\" rename=\"", importBind.left.text, "\"/>");
+    }
 
-	override void visit(const InExpression inExpression)
-	{
-		if (inExpression.negated)
-			output.writeln("<inExpression operator=\"!in\">");
-		else
-			output.writeln("<inExpression operator=\"in\">");
-		output.writeln("<left>");
-		visit(inExpression.left);
-		output.writeln("</left>");
-		output.writeln("<right>");
-		visit(inExpression.right);
-		output.writeln("</right>");
-		output.writeln("</inExpression>");
-	}
+    override void visit(const InExpression inExpression)
+    {
+        if (inExpression.negated)
+            output.writeln("<inExpression operator=\"!in\">");
+        else
+            output.writeln("<inExpression operator=\"in\">");
+        output.writeln("<left>");
+        visit(inExpression.left);
+        output.writeln("</left>");
+        output.writeln("<right>");
+        visit(inExpression.right);
+        output.writeln("</right>");
+        output.writeln("</inExpression>");
+    }
 
-	override void visit(const Initialize initialize)
-	{
-		if (initialize.statementNoCaseNoDefault is null)
-			output.writeln("<initialize/>");
-		else
-		{
-			output.writeln("<initialize>");
-			visit(initialize.statementNoCaseNoDefault);
-			output.writeln("</initialize>");
-		}
-	}
+    override void visit(const Initialize initialize)
+    {
+        if (initialize.statementNoCaseNoDefault is null)
+            output.writeln("<initialize/>");
+        else
+        {
+            output.writeln("<initialize>");
+            visit(initialize.statementNoCaseNoDefault);
+            output.writeln("</initialize>");
+        }
+    }
 
-	override void visit(const Initializer initializer)
-	{
-		if (initializer.nonVoidInitializer is null)
-			output.writeln("<initializer void=\"true\"/>");
-		else
-		{
-			output.writeln("<initializer>");
-			visit(initializer.nonVoidInitializer);
-			output.writeln("</initializer>");
-		}
-	}
+    override void visit(const Initializer initializer)
+    {
+        if (initializer.nonVoidInitializer is null)
+            output.writeln("<initializer void=\"true\"/>");
+        else
+        {
+            output.writeln("<initializer>");
+            visit(initializer.nonVoidInitializer);
+            output.writeln("</initializer>");
+        }
+    }
 
-	override void visit(const InterfaceDeclaration interfaceDec)
-	{
-		output.writeln("<interfaceDeclaration line=\"", interfaceDec.name.line, "\">");
-		output.writeln("<name>", interfaceDec.name.text, "</name>");
+    override void visit(const InterfaceDeclaration interfaceDec)
+    {
+        output.writeln("<interfaceDeclaration line=\"", interfaceDec.name.line, "\">");
+        output.writeln("<name>", interfaceDec.name.text, "</name>");
         writeDdoc(interfaceDec.comment);
-		interfaceDec.accept(this);
-		output.writeln("</interfaceDeclaration>");
-	}
+        interfaceDec.accept(this);
+        output.writeln("</interfaceDeclaration>");
+    }
 
-	override void visit(const Invariant invariant_)
-	{
-		output.writeln("<invariant>");
+    override void visit(const Invariant invariant_)
+    {
+        output.writeln("<invariant>");
         writeDdoc(invariant_.comment);
-		invariant_.accept(this);
-		output.writeln("</invariant>");
-	}
+        invariant_.accept(this);
+        output.writeln("</invariant>");
+    }
 
-	override void visit(const IsExpression isExpression)
-	{
-		output.writeln("<isExpression>");
-		visit(isExpression.type);
-		if (isExpression.identifier.type != tok!"")
-			visit(isExpression.identifier);
-		if (isExpression.typeSpecialization !is null)
-		{
-			if (isExpression.equalsOrColon == tok!":")
-				output.writeln("<colon/>");
-			else
-				output.writeln("<equals/>");
-			visit(isExpression.typeSpecialization);
-			if (isExpression.templateParameterList !is null)
-				visit(isExpression.templateParameterList);
-		}
-		output.writeln("</isExpression>");
-	}
+    override void visit(const IsExpression isExpression)
+    {
+        output.writeln("<isExpression>");
+        visit(isExpression.type);
+        if (isExpression.identifier.type != tok!"")
+            visit(isExpression.identifier);
+        if (isExpression.typeSpecialization !is null)
+        {
+            if (isExpression.equalsOrColon == tok!":")
+                output.writeln("<colon/>");
+            else
+                output.writeln("<equals/>");
+            visit(isExpression.typeSpecialization);
+            if (isExpression.templateParameterList !is null)
+                visit(isExpression.templateParameterList);
+        }
+        output.writeln("</isExpression>");
+    }
 
-	override void visit(const KeyValuePair keyValuePair)
-	{
-		output.writeln("<keyValuePair>");
-		output.writeln("<key>");
-		visit(keyValuePair.key);
-		output.writeln("</key>");
-		output.writeln("<value>");
-		visit(keyValuePair.value);
-		output.writeln("</value>");
-		output.writeln("</keyValuePair>");
-	}
+    override void visit(const KeyValuePair keyValuePair)
+    {
+        output.writeln("<keyValuePair>");
+        output.writeln("<key>");
+        visit(keyValuePair.key);
+        output.writeln("</key>");
+        output.writeln("<value>");
+        visit(keyValuePair.value);
+        output.writeln("</value>");
+        output.writeln("</keyValuePair>");
+    }
 
-	override void visit (const LabeledStatement labeledStatement)
-	{
-		output.writeln("<labeledStatement label=\"",
-			labeledStatement.identifier.text ,"\">");
-		visit(labeledStatement.declarationOrStatement);
-		output.writeln("</labeledStatement>");
-	}
+    override void visit (const LabeledStatement labeledStatement)
+    {
+        output.writeln("<labeledStatement label=\"",
+            labeledStatement.identifier.text ,"\">");
+        visit(labeledStatement.declarationOrStatement);
+        output.writeln("</labeledStatement>");
+    }
 
-	override void visit(const LambdaExpression lambdaExpression)
-	{
-		output.writeln("<lambdaExpression>");
-		if (lambdaExpression.functionType == tok!"function")
-			output.writeln("<function/>");
-		if (lambdaExpression.functionType == tok!"delegate")
-			output.writeln("<delegate/>");
-		lambdaExpression.accept(this);
-		output.writeln("</lambdaExpression>");
-	}
+    override void visit(const LambdaExpression lambdaExpression)
+    {
+        output.writeln("<lambdaExpression>");
+        if (lambdaExpression.functionType == tok!"function")
+            output.writeln("<function/>");
+        if (lambdaExpression.functionType == tok!"delegate")
+            output.writeln("<delegate/>");
+        lambdaExpression.accept(this);
+        output.writeln("</lambdaExpression>");
+    }
 
-	override void visit(const LinkageAttribute linkageAttribute)
-	{
-		if (linkageAttribute.hasPlusPlus)
-			output.writeln("<linkageAttribute linkage=\"c++\"/>");
-		else
-			output.writeln("<linkageAttribute linkage=\"",
-				linkageAttribute.identifier.text, "\"/>");
-	}
+    override void visit(const LinkageAttribute linkageAttribute)
+    {
+        if (linkageAttribute.hasPlusPlus)
+            output.writeln("<linkageAttribute linkage=\"c++\"/>");
+        else
+            output.writeln("<linkageAttribute linkage=\"",
+                linkageAttribute.identifier.text, "\"/>");
+    }
 
-	override void visit(const MemberFunctionAttribute memberFunctionAttribute)
-	{
-		output.writeln("<memberFunctionAttribute>");
-		if (memberFunctionAttribute.atAttribute is null)
-			output.writeln(str(memberFunctionAttribute.tokenType));
-		else
-			memberFunctionAttribute.accept(this);
-		output.writeln("</memberFunctionAttribute>");
-	}
+    override void visit(const MemberFunctionAttribute memberFunctionAttribute)
+    {
+        output.writeln("<memberFunctionAttribute>");
+        if (memberFunctionAttribute.atAttribute is null)
+            output.writeln(str(memberFunctionAttribute.tokenType));
+        else
+            memberFunctionAttribute.accept(this);
+        output.writeln("</memberFunctionAttribute>");
+    }
 
-	override void visit(const Module module_)
-	{
-		output.writeln("<?xml version=\"1.0\"?>");
-		output.writeln("<module>");
-		module_.accept(this);
-		output.writeln("</module>");
-	}
+    override void visit(const Module module_)
+    {
+        output.writeln("<?xml version=\"1.0\"?>");
+        output.writeln("<module>");
+        module_.accept(this);
+        output.writeln("</module>");
+    }
 
-	override void visit(const MulExpression mulExpression)
-	{
-		output.writeln("<mulExpression operator=\"", str(mulExpression.operator) ,"\">");
-		output.writeln("<left>");
-		visit(mulExpression.left);
-		output.writeln("</left>");
-		if (mulExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(mulExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</mulExpression>");
-	}
+    override void visit(const MulExpression mulExpression)
+    {
+        output.writeln("<mulExpression operator=\"", str(mulExpression.operator) ,"\">");
+        output.writeln("<left>");
+        visit(mulExpression.left);
+        output.writeln("</left>");
+        if (mulExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(mulExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</mulExpression>");
+    }
 
-	override void visit(const OrOrExpression orOrExpression)
-	{
-		output.writeln("<orOrExpression>");
-		output.writeln("<left>");
-		visit(orOrExpression.left);
-		output.writeln("</left>");
-		if (orOrExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(orOrExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</orOrExpression>");
-	}
+    override void visit(const OrOrExpression orOrExpression)
+    {
+        output.writeln("<orOrExpression>");
+        output.writeln("<left>");
+        visit(orOrExpression.left);
+        output.writeln("</left>");
+        if (orOrExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(orOrExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</orOrExpression>");
+    }
 
-	override void visit(const Parameter param)
-	{
-		output.writeln("<parameter>");
-		if (param.name.type == tok!"identifier")
-			output.writeln("<name>", param.name.text, "</name>");
-		foreach (attribute; param.parameterAttributes)
-		{
-			output.writeln("<parameterAttribute>", str(attribute), "</parameterAttribute>");
-		}
-		param.accept(this);
-		if (param.vararg)
-			output.writeln("<vararg/>");
-		output.writeln("</parameter>");
-	}
+    override void visit(const Parameter param)
+    {
+        output.writeln("<parameter>");
+        if (param.name.type == tok!"identifier")
+            output.writeln("<name>", param.name.text, "</name>");
+        foreach (attribute; param.parameterAttributes)
+        {
+            output.writeln("<parameterAttribute>", str(attribute), "</parameterAttribute>");
+        }
+        param.accept(this);
+        if (param.vararg)
+            output.writeln("<vararg/>");
+        output.writeln("</parameter>");
+    }
 
-	override void visit(const PostIncDecExpression postIncDecExpression)
-	{
-		output.writeln("<postIncDecExpression operator=\"",
-			str(postIncDecExpression.operator), "\">");
-		postIncDecExpression.accept(this);
-		output.writeln("</postIncDecExpression>");
-	}
 
-	override void visit(const PowExpression powExpression)
-	{
-		output.writeln("<powExpression>");
-		output.writeln("<left>");
-		visit(powExpression.left);
-		output.writeln("</left>");
-		if (powExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(powExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</powExpression>");
-	}
+    override void visit(const PowExpression powExpression)
+    {
+        output.writeln("<powExpression>");
+        output.writeln("<left>");
+        visit(powExpression.left);
+        output.writeln("</left>");
+        if (powExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(powExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</powExpression>");
+    }
 
-	override void visit(const PreIncDecExpression preIncDecExpression)
-	{
-		output.writeln("<preIncDecExpression operator=\"",
-			str(preIncDecExpression.operator), "\">");
-		preIncDecExpression.accept(this);
-		output.writeln("</preIncDecExpression>");
-	}
+    override void visit(const RelExpression relExpression)
+    {
+        output.writeln("<relExpression operator=\"",
+            xmlAttributeEscape(str(relExpression.operator)), "\">");
+        output.writeln("<left>");
+        visit(relExpression.left);
+        output.writeln("</left>");
+        output.writeln("<right>");
+        visit(relExpression.right);
+        output.writeln("</right>");
+        output.writeln("</relExpression>");
+    }
 
-	override void visit(const RelExpression relExpression)
-	{
-		output.writeln("<relExpression operator=\"",
-			xmlAttributeEscape(str(relExpression.operator)), "\">");
-		output.writeln("<left>");
-		visit(relExpression.left);
-		output.writeln("</left>");
-		output.writeln("<right>");
-		visit(relExpression.right);
-		output.writeln("</right>");
-		output.writeln("</relExpression>");
-	}
+    override void visit(const ReturnStatement returnStatement)
+    {
+        if (returnStatement.expression is null)
+            output.writeln("<returnStatement/>");
+        else
+        {
+            output.writeln("<returnStatement>");
+            returnStatement.accept(this);
+            output.writeln("</returnStatement>");
+        }
+    }
 
-	override void visit(const ReturnStatement returnStatement)
-	{
-		if (returnStatement.expression is null)
-			output.writeln("<returnStatement/>");
-		else
-		{
-			output.writeln("<returnStatement>");
-			returnStatement.accept(this);
-			output.writeln("</returnStatement>");
-		}
-	}
+    override void visit(const ShiftExpression shiftExpression)
+    {
+        output.writeln("<shiftExpression operator=\"",
+            xmlAttributeEscape(str(shiftExpression.operator)), "\">");
+        output.writeln("<left>");
+        visit(shiftExpression.left);
+        output.writeln("</left>");
+        output.writeln("<right>");
+        visit(shiftExpression.right);
+        output.writeln("</right>");
+        output.writeln("</shiftExpression>");
+    }
 
-	override void visit(const ShiftExpression shiftExpression)
-	{
-		output.writeln("<shiftExpression operator=\"",
-			xmlAttributeEscape(str(shiftExpression.operator)), "\">");
-		output.writeln("<left>");
-		visit(shiftExpression.left);
-		output.writeln("</left>");
-		output.writeln("<right>");
-		visit(shiftExpression.right);
-		output.writeln("</right>");
-		output.writeln("</shiftExpression>");
-	}
+    override void visit(const SingleImport singleImport)
+    {
+        if (singleImport.rename.type == tok!"")
+            output.writeln("<singleImport>");
+        else
+            output.writeln("<singleImport rename=\"", singleImport.rename.text, "\">");
+        visit(singleImport.identifierChain);
+        output.writeln("</singleImport>");
+    }
 
-	override void visit(const SingleImport singleImport)
-	{
-		if (singleImport.rename.type == tok!"")
-			output.writeln("<singleImport>");
-		else
-			output.writeln("<singleImport rename=\"", singleImport.rename.text, "\">");
-		visit(singleImport.identifierChain);
-		output.writeln("</singleImport>");
-	}
+    override void visit(const SliceExpression sliceExpression)
+    {
+        output.writeln("<sliceExpression>");
+        visit(sliceExpression.unaryExpression);
+        if (sliceExpression.lower !is null)
+        {
+            output.writeln("<low>");
+            visit(sliceExpression.lower);
+            output.writeln("</low>");
+        }
+        if (sliceExpression.upper !is null)
+        {
+            output.writeln("<high>");
+            visit(sliceExpression.upper);
+            output.writeln("</high>");
+        }
+        output.writeln("</sliceExpression>");
+    }
 
-	override void visit(const SliceExpression sliceExpression)
-	{
-		output.writeln("<sliceExpression>");
-		visit(sliceExpression.unaryExpression);
-		if (sliceExpression.lower !is null)
-		{
-			output.writeln("<low>");
-			visit(sliceExpression.lower);
-			output.writeln("</low>");
-		}
-		if (sliceExpression.upper !is null)
-		{
-			output.writeln("<high>");
-			visit(sliceExpression.upper);
-			output.writeln("</high>");
-		}
-		output.writeln("</sliceExpression>");
-	}
+    override void visit(const StructDeclaration structDec)
+    {
+        output.writeln("<structDeclaration line=\"", structDec.name.line, "\">");
+        output.writeln("<name>", structDec.name.text, "</name>");
+        writeDdoc(structDec.comment);
+        structDec.accept(this);
+        output.writeln("</structDeclaration>");
+    }
 
-	override void visit(const StructDeclaration structDec)
-	{
-		output.writeln("<structDeclaration line=\"", structDec.name.line, "\">");
-		output.writeln("<name>", structDec.name.text, "</name>");
-		writeDdoc(structDec.comment);
-		structDec.accept(this);
-		output.writeln("</structDeclaration>");
-	}
+    override void visit(const TemplateAliasParameter templateAliasParameter)
+    {
+        output.writeln("<templateAliasParameter>");
+        if (templateAliasParameter.type !is null)
+            visit(templateAliasParameter.type);
+        visit(templateAliasParameter.identifier);
+        if (templateAliasParameter.colonExpression !is null)
+        {
+            output.writeln("<specialization>");
+            visit(templateAliasParameter.colonExpression);
+            output.writeln("</specialization>");
+        }
+        else if (templateAliasParameter.colonType !is null)
+        {
+            output.writeln("<specialization>");
+            visit(templateAliasParameter.colonType);
+            output.writeln("</specialization>");
+        }
 
-	override void visit(const TemplateAliasParameter templateAliasParameter)
-	{
-		output.writeln("<templateAliasParameter>");
-		if (templateAliasParameter.type !is null)
-			visit(templateAliasParameter.type);
-		visit(templateAliasParameter.identifier);
-		if (templateAliasParameter.colonExpression !is null)
-		{
-			output.writeln("<specialization>");
-			visit(templateAliasParameter.colonExpression);
-			output.writeln("</specialization>");
-		}
-		else if (templateAliasParameter.colonType !is null)
-		{
-			output.writeln("<specialization>");
-			visit(templateAliasParameter.colonType);
-			output.writeln("</specialization>");
-		}
+        if (templateAliasParameter.assignExpression !is null)
+        {
+            output.writeln("<default>");
+            visit(templateAliasParameter.assignExpression);
+            output.writeln("</default>");
+        }
+        else if (templateAliasParameter.assignType !is null)
+        {
+            output.writeln("<default>");
+            visit(templateAliasParameter.assignType);
+            output.writeln("</default>");
+        }
 
-		if (templateAliasParameter.assignExpression !is null)
-		{
-			output.writeln("<default>");
-			visit(templateAliasParameter.assignExpression);
-			output.writeln("</default>");
-		}
-		else if (templateAliasParameter.assignType !is null)
-		{
-			output.writeln("<default>");
-			visit(templateAliasParameter.assignType);
-			output.writeln("</default>");
-		}
+        output.writeln("</templateAliasParameter>");
+    }
 
-		output.writeln("</templateAliasParameter>");
-	}
-
-	override void visit(const TemplateDeclaration templateDeclaration)
-	{
-		if (templateDeclaration.eponymousTemplateDeclaration !is null)
-		{
-			output.writeln("<templateDeclaration>");
-			visit(templateDeclaration.eponymousTemplateDeclaration);
-			output.writeln("</templateDeclaration>");
-			return;
-		}
+    override void visit(const TemplateDeclaration templateDeclaration)
+    {
         writeDdoc(templateDeclaration.comment);
-		output.writeln("<templateDeclaration line=\"",
-			templateDeclaration.name.line, "\">");
-		output.writeln("<name>", templateDeclaration.name.text, "</name>");
-		visit(templateDeclaration.templateParameters);
-		if (templateDeclaration.constraint !is null)
-			visit(templateDeclaration.constraint);
-		foreach (dec; templateDeclaration.declarations)
-		{
-			if (dec !is null) visit(dec);
-		}
-		output.writeln("</templateDeclaration>");
-	}
+        output.writeln("<templateDeclaration line=\"",
+            templateDeclaration.name.line, "\">");
+        output.writeln("<name>", templateDeclaration.name.text, "</name>");
+        visit(templateDeclaration.templateParameters);
+        if (templateDeclaration.constraint !is null)
+            visit(templateDeclaration.constraint);
+        foreach (dec; templateDeclaration.declarations)
+        {
+            if (dec !is null) visit(dec);
+        }
+        output.writeln("</templateDeclaration>");
+    }
 
-	override void visit(const Token token)
-	{
-		string tagName;
-		switch (token.type)
-		{
-		case tok!"": return;
-		case tok!"identifier": tagName = "identifier"; break;
-		case tok!"doubleLiteral": tagName = "doubleLiteral"; break;
-		case tok!"idoubleLiteral": tagName = "idoubleLiteral"; break;
-		case tok!"floatLiteral": tagName = "floatLiteral"; break;
-		case tok!"ifloatLiteral": tagName = "ifloatLiteral"; break;
-		case tok!"intLiteral": tagName = "intLiteral"; break;
-		case tok!"uintLiteral": tagName = "uintLiteral"; break;
-		case tok!"longLiteral": tagName = "longLiteral"; break;
-		case tok!"ulongLiteral": tagName = "ulongLiteral"; break;
-		case tok!"realLiteral": tagName = "realLiteral"; break;
-		case tok!"irealLiteral": tagName = "irealLiteral"; break;
-		case tok!"characterLiteral": tagName = "characterLiteral"; break;
-		case tok!"stringLiteral": tagName = "stringLiteral"; break;
-		case tok!"dstringLiteral": tagName = "dstringLiteral"; break;
-		case tok!"wstringLiteral": tagName = "wstringLiteral"; break;
-		case tok!"scriptLine": tagName = "scriptLine"; break;
-		case tok!"$": output.writeln("<dollar/>"); return;
-		case tok!".": output.writeln("<dot/>"); return;
-		default: output.writeln("<", str(token.type), "/>"); return;
-		}
-		output.writeln("<", tagName, ">", xmlEscape(token.text), "</", tagName, ">");
-	}
+    override void visit(const Token token)
+    {
+        string tagName;
+        switch (token.type)
+        {
+        case tok!"": return;
+        case tok!"identifier": tagName = "identifier"; break;
+        case tok!"doubleLiteral": tagName = "doubleLiteral"; break;
+        case tok!"idoubleLiteral": tagName = "idoubleLiteral"; break;
+        case tok!"floatLiteral": tagName = "floatLiteral"; break;
+        case tok!"ifloatLiteral": tagName = "ifloatLiteral"; break;
+        case tok!"intLiteral": tagName = "intLiteral"; break;
+        case tok!"uintLiteral": tagName = "uintLiteral"; break;
+        case tok!"longLiteral": tagName = "longLiteral"; break;
+        case tok!"ulongLiteral": tagName = "ulongLiteral"; break;
+        case tok!"realLiteral": tagName = "realLiteral"; break;
+        case tok!"irealLiteral": tagName = "irealLiteral"; break;
+        case tok!"characterLiteral": tagName = "characterLiteral"; break;
+        case tok!"stringLiteral": tagName = "stringLiteral"; break;
+        case tok!"dstringLiteral": tagName = "dstringLiteral"; break;
+        case tok!"wstringLiteral": tagName = "wstringLiteral"; break;
+        case tok!"scriptLine": tagName = "scriptLine"; break;
+        case tok!"$": output.writeln("<dollar/>"); return;
+        case tok!".": output.writeln("<dot/>"); return;
+        default: output.writeln("<", str(token.type), "/>"); return;
+        }
+        output.writeln("<", tagName, ">", xmlEscape(token.text), "</", tagName, ">");
+    }
 
-	override void visit(const Type type)
-	{
-		auto app = appender!string();
-		auto formatter = new Formatter!(typeof(app))(app);
-		formatter.format(type);
-		output.writeln("<type pretty=\"", xmlAttributeEscape(app.data), "\">");
-		type.accept(this);
-		output.writeln("</type>");
-	}
+    override void visit(const Type type)
+    {
+        auto app = appender!string();
+        auto formatter = new Formatter!(typeof(app))(app);
+        formatter.format(type);
+        output.writeln("<type pretty=\"", xmlAttributeEscape(app.data), "\">");
+        type.accept(this);
+        output.writeln("</type>");
+    }
 
-	override void visit(const Type2 type2)
-	{
-		if (type2.builtinType != tok!"")
-			output.writeln("<type2>", str(type2.builtinType), "</type2>");
-		else
-		{
-			output.writeln("<type2>");
-			type2.accept(this);
-			output.writeln("</type2>");
-		}
-	}
+    override void visit(const Type2 type2)
+    {
+        if (type2.builtinType != tok!"")
+            output.writeln("<type2>", str(type2.builtinType), "</type2>");
+        else
+        {
+            output.writeln("<type2>");
+            type2.accept(this);
+            output.writeln("</type2>");
+        }
+    }
 
-	override void visit(const TypeSuffix typeSuffix)
-	{
-		if (typeSuffix.star)
-			output.writeln("<typeSuffix type=\"*\"/>");
-		else if (typeSuffix.array)
-		{
-			if (typeSuffix.low is null && typeSuffix.type is null)
-				output.writeln("<typeSuffix type=\"[]\"/>");
-			else
-			{
-				if (typeSuffix.low is null)
-				{
-					output.writeln("<typeSuffix type=\"[]\">");
-					visit(typeSuffix.type);
-					output.writeln("</typeSuffix>");
-				}
-				else
-				{
-					output.writeln("<typeSuffix type=\"[]\">");
-					if (typeSuffix.high !is null)
-					{
-						output.writeln("<low>");
-						visit(typeSuffix.low);
-						output.writeln("</low>");
-						output.writeln("<high>");
-						visit(typeSuffix.high);
-						output.writeln("</high>");
-					}
-					else
-						visit(typeSuffix.low);
-					output.writeln("</typeSuffix>");
-				}
-			}
-		}
-		else
-		{
-			visit(typeSuffix.delegateOrFunction);
-			visit(typeSuffix.parameters);
-			foreach (attr; typeSuffix.memberFunctionAttributes)
-			{
-				if (attr !is null) visit(attr);
-			}
-		}
-	}
+    override void visit(const TypeSuffix typeSuffix)
+    {
+        if (typeSuffix.star)
+            output.writeln("<typeSuffix type=\"*\"/>");
+        else if (typeSuffix.array)
+        {
+            if (typeSuffix.low is null && typeSuffix.type is null)
+                output.writeln("<typeSuffix type=\"[]\"/>");
+            else
+            {
+                if (typeSuffix.low is null)
+                {
+                    output.writeln("<typeSuffix type=\"[]\">");
+                    visit(typeSuffix.type);
+                    output.writeln("</typeSuffix>");
+                }
+                else
+                {
+                    output.writeln("<typeSuffix type=\"[]\">");
+                    if (typeSuffix.high !is null)
+                    {
+                        output.writeln("<low>");
+                        visit(typeSuffix.low);
+                        output.writeln("</low>");
+                        output.writeln("<high>");
+                        visit(typeSuffix.high);
+                        output.writeln("</high>");
+                    }
+                    else
+                        visit(typeSuffix.low);
+                    output.writeln("</typeSuffix>");
+                }
+            }
+        }
+        else
+        {
+            visit(typeSuffix.delegateOrFunction);
+            visit(typeSuffix.parameters);
+            foreach (attr; typeSuffix.memberFunctionAttributes)
+            {
+                if (attr !is null) visit(attr);
+            }
+        }
+    }
 
-	override void visit(const UnaryExpression unaryExpression)
-	{
-		output.writeln("<unaryExpression>");
-		if (unaryExpression.prefix != tok!"")
-		{
-			output.writeln("<prefix>", xmlEscape(str(unaryExpression.prefix.type)),
-				"</prefix>");
-			unaryExpression.unaryExpression.accept(this);
-		}
-		if (unaryExpression.suffix != tok!"")
-		{
-			assert(unaryExpression.suffix.text == "");
-			unaryExpression.unaryExpression.accept(this);
-			output.writeln("<suffix>", str(unaryExpression.suffix.type),
-				"</suffix>");
-		}
-		else
-			unaryExpression.accept(this);
-		output.writeln("</unaryExpression>");
-	}
+    override void visit(const UnaryExpression unaryExpression)
+    {
+        output.writeln("<unaryExpression>");
+        if (unaryExpression.prefix != tok!"")
+        {
+            output.writeln("<prefix>", xmlEscape(str(unaryExpression.prefix.type)),
+                "</prefix>");
+            unaryExpression.unaryExpression.accept(this);
+        }
+        if (unaryExpression.suffix != tok!"")
+        {
+            assert(unaryExpression.suffix.text == "");
+            unaryExpression.unaryExpression.accept(this);
+            output.writeln("<suffix>", str(unaryExpression.suffix.type),
+                "</suffix>");
+        }
+        else
+            unaryExpression.accept(this);
+        output.writeln("</unaryExpression>");
+    }
 
-	override void visit(const UnionDeclaration unionDeclaration)
-	{
-		output.writeln("<unionDeclaration line=\"", unionDeclaration.name.line, "\">");
-		if (unionDeclaration.name != tok!"")
-			output.writeln("<name>", unionDeclaration.name.text, "</name>");
-		if (unionDeclaration.templateParameters !is null)
-			visit(unionDeclaration.templateParameters);
-		if (unionDeclaration.constraint !is null)
-			visit(unionDeclaration.constraint);
-		if (unionDeclaration.structBody !is null)
-			visit(unionDeclaration.structBody);
-		output.writeln("</unionDeclaration>");
-	}
+    override void visit(const UnionDeclaration unionDeclaration)
+    {
+        output.writeln("<unionDeclaration line=\"", unionDeclaration.name.line, "\">");
+        if (unionDeclaration.name != tok!"")
+            output.writeln("<name>", unionDeclaration.name.text, "</name>");
+        if (unionDeclaration.templateParameters !is null)
+            visit(unionDeclaration.templateParameters);
+        if (unionDeclaration.constraint !is null)
+            visit(unionDeclaration.constraint);
+        if (unionDeclaration.structBody !is null)
+            visit(unionDeclaration.structBody);
+        output.writeln("</unionDeclaration>");
+    }
 
-	override void visit(const Unittest unittest_)
-	{
-		output.writeln("<unittest>");
-		unittest_.accept(this);
-		output.writeln("</unittest>");
-	}
+    override void visit(const Unittest unittest_)
+    {
+        output.writeln("<unittest>");
+        unittest_.accept(this);
+        output.writeln("</unittest>");
+    }
 
-	override void visit(const VariableDeclaration variableDeclaration)
-	{
+    override void visit(const VariableDeclaration variableDeclaration)
+    {
         output.writeln("<variableDeclaration>");
         writeDdoc(variableDeclaration.comment);
         variableDeclaration.accept(this);
         output.writeln("</variableDeclaration>");
-	}
+    }
 
-	override void visit(const XorExpression xorExpression)
-	{
-		output.writeln("<xorExpression>");
-		output.writeln("<left>");
-		visit(xorExpression.left);
-		output.writeln("</left>");
-		if (xorExpression.right !is null)
-		{
-			output.writeln("<right>");
-			visit(xorExpression.right);
-			output.writeln("</right>");
-		}
-		output.writeln("</xorExpression>");
-	}
+    override void visit(const XorExpression xorExpression)
+    {
+        output.writeln("<xorExpression>");
+        output.writeln("<left>");
+        visit(xorExpression.left);
+        output.writeln("</left>");
+        if (xorExpression.right !is null)
+        {
+            output.writeln("<right>");
+            visit(xorExpression.right);
+            output.writeln("</right>");
+        }
+        output.writeln("</xorExpression>");
+    }
 
-	override void visit(const AliasInitializer aliasInitializer) { mixin (tagAndAccept!"aliasInitializer"); }
-	override void visit(const AliasThisDeclaration aliasThisDeclaration) { mixin (tagAndAccept!"aliasThisDeclaration"); }
-	override void visit(const ArgumentList argumentList) { mixin (tagAndAccept!"argumentList"); }
-	override void visit(const Arguments arguments) { mixin (tagAndAccept!"arguments"); }
-	override void visit(const ArrayInitializer arrayInitializer) { mixin (tagAndAccept!"arrayInitializer"); }
-	override void visit(const ArrayLiteral arrayLiteral) { mixin (tagAndAccept!"arrayLiteral"); }
-	override void visit(const ArrayMemberInitialization arrayMemberInitialization) { mixin (tagAndAccept!"arrayMemberInitialization"); }
-	override void visit(const AsmAddExp asmAddExp) { mixin (tagAndAccept!"asmAddExp"); }
-	override void visit(const AsmAndExp asmAndExp) { mixin (tagAndAccept!"asmAndExp"); }
-	override void visit(const AsmBrExp asmBrExp) { mixin (tagAndAccept!"asmBrExp"); }
-	override void visit(const AsmEqualExp asmEqualExp) { mixin (tagAndAccept!"asmEqualExp"); }
-	override void visit(const AsmExp asmExp) { mixin (tagAndAccept!"asmExp"); }
-	override void visit(const AsmLogAndExp asmLogAndExp) { mixin (tagAndAccept!"asmLogAndExp"); }
-	override void visit(const AsmLogOrExp asmLogOrExp) { mixin (tagAndAccept!"asmLogOrExp"); }
-	override void visit(const AsmMulExp asmMulExp) { mixin (tagAndAccept!"asmMulExp"); }
-	override void visit(const AsmOrExp asmOrExp) { mixin (tagAndAccept!"asmOrExp"); }
-	override void visit(const AsmPrimaryExp asmPrimaryExp) { mixin (tagAndAccept!"asmPrimaryExp"); }
-	override void visit(const AsmRelExp asmRelExp) { mixin (tagAndAccept!"asmRelExp"); }
-	override void visit(const AsmShiftExp asmShiftExp) { mixin (tagAndAccept!"asmShiftExp"); }
-	override void visit(const AsmStatement asmStatement) { mixin (tagAndAccept!"asmStatement"); }
-	override void visit(const AsmTypePrefix asmTypePrefix) { mixin (tagAndAccept!"asmTypePrefix"); }
-	override void visit(const AsmUnaExp asmUnaExp) { mixin (tagAndAccept!"asmUnaExp"); }
-	override void visit(const AsmXorExp asmXorExp) { mixin (tagAndAccept!"asmXorExp"); }
-	override void visit(const AssocArrayLiteral assocArrayLiteral) { mixin (tagAndAccept!"assocArrayLiteral"); }
-	override void visit(const AttributeDeclaration attributeDeclaration) { mixin (tagAndAccept!"attributeDeclaration"); }
-	override void visit(const BaseClass baseClass) { mixin (tagAndAccept!"baseClass"); }
-	override void visit(const BaseClassList baseClassList) { mixin (tagAndAccept!"baseClassList"); }
-	override void visit(const BlockStatement blockStatement) { mixin (tagAndAccept!"blockStatement"); }
-	override void visit(const BodyStatement bodyStatement) { mixin (tagAndAccept!"bodyStatement"); }
-	override void visit(const CaseStatement caseStatement) { mixin (tagAndAccept!"caseStatement"); }
-	override void visit(const CastExpression castExpression) { mixin (tagAndAccept!"castExpression"); }
-	override void visit(const CastQualifier castQualifier) { mixin (tagAndAccept!"castQualifier"); }
-	override void visit(const Catches catches) { mixin (tagAndAccept!"catches"); }
-	override void visit(const CmpExpression cmpExpression) { mixin (tagAndAccept!"cmpExpression"); }
-	override void visit(const CompileCondition compileCondition) { mixin (tagAndAccept!"compileCondition"); }
-	override void visit(const Constraint constraint) { mixin (tagAndAccept!"constraint"); }
-	override void visit(const Constructor constructor) { mixin (tagAndAccept!"constructor"); }
-	override void visit(const Declaration declaration) { mixin (tagAndAccept!"declaration"); }
-	override void visit(const DeclarationOrStatement declarationOrStatement) { mixin (tagAndAccept!"declarationOrStatement"); }
-	override void visit(const DeclarationsAndStatements declarationsAndStatements) { mixin (tagAndAccept!"declarationsAndStatements"); }
-	override void visit(const DefaultStatement defaultStatement) { mixin (tagAndAccept!"defaultStatement"); }
-	override void visit(const DeleteExpression deleteExpression) { mixin (tagAndAccept!"deleteExpression"); }
-	override void visit(const DeleteStatement deleteStatement) { mixin (tagAndAccept!"deleteStatement"); }
-	override void visit(const Destructor destructor) { mixin (tagAndAccept!"destructor"); }
-	override void visit(const DoStatement doStatement) { mixin (tagAndAccept!"doStatement"); }
-	override void visit(const EnumBody enumBody) { mixin (tagAndAccept!"enumBody"); }
-	override void visit(const EponymousTemplateDeclaration eponymousTemplateDeclaration) { mixin (tagAndAccept!"eponymousTemplateDeclaration"); }
-	override void visit(const Expression expression) { mixin (tagAndAccept!"expression"); }
-	override void visit(const ExpressionStatement expressionStatement) { mixin (tagAndAccept!"expressionStatement"); }
-	override void visit(const FinalSwitchStatement finalSwitchStatement) { mixin (tagAndAccept!"finalSwitchStatement"); }
-	override void visit(const ForeachTypeList foreachTypeList) { mixin (tagAndAccept!"foreachTypeList"); }
-	override void visit(const FunctionAttribute functionAttribute) { mixin (tagAndAccept!"functionAttribute"); }
-	override void visit(const FunctionBody functionBody) { mixin (tagAndAccept!"functionBody"); }
-	override void visit(const FunctionCallExpression functionCallExpression) { mixin (tagAndAccept!"functionCallExpression"); }
-	override void visit(const IdentifierChain identifierChain) { mixin (tagAndAccept!"identifierChain"); }
-	override void visit(const IdentifierList identifierList) { mixin (tagAndAccept!"identifierList"); }
-	override void visit(const IdentifierOrTemplateChain identifierOrTemplateChain) { mixin (tagAndAccept!"identifierOrTemplateChain"); }
-	override void visit(const IdentifierOrTemplateInstance identifierOrTemplateInstance) { mixin (tagAndAccept!"identifierOrTemplateInstance"); }
-	override void visit(const ImportBindings importBindings) { mixin (tagAndAccept!"importBindings"); }
-	override void visit(const ImportDeclaration importDeclaration) { mixin (tagAndAccept!"importDeclaration"); }
-	override void visit(const ImportExpression importExpression) { mixin (tagAndAccept!"importExpression"); }
-	override void visit(const IndexExpression indexExpression) { mixin (tagAndAccept!"indexExpression"); }
-	override void visit(const InStatement inStatement) { mixin (tagAndAccept!"inStatement"); }
-	override void visit(const KeyValuePairs keyValuePairs) { mixin (tagAndAccept!"keyValuePairs"); }
-	override void visit(const MixinExpression mixinExpression) { mixin (tagAndAccept!"mixinExpression"); }
-	override void visit(const MixinTemplateDeclaration mixinTemplateDeclaration) { mixin (tagAndAccept!"mixinTemplateDeclaration"); }
-	override void visit(const MixinTemplateName mixinTemplateName) { mixin (tagAndAccept!"mixinTemplateName"); }
-	override void visit(const ModuleDeclaration moduleDeclaration) { mixin (tagAndAccept!"moduleDeclaration"); }
-	override void visit(const LastCatch lastCatch) { mixin (tagAndAccept!"lastCatch"); }
-	override void visit(const NewExpression newExpression) { mixin (tagAndAccept!"newExpression"); }
-	override void visit(const NonVoidInitializer nonVoidInitializer) { mixin (tagAndAccept!"nonVoidInitializer"); }
-	override void visit(const Operands operands) { mixin (tagAndAccept!"operands"); }
-	override void visit(const OrExpression orExpression) { mixin (tagAndAccept!"orExpression"); }
-	override void visit(const OutStatement outStatement) { mixin (tagAndAccept!"outStatement"); } override void visit(const MixinDeclaration mixinDeclaration) { mixin (tagAndAccept!"mixinDeclaration"); }
-	override void visit(const Parameters parameters) { mixin (tagAndAccept!"parameters"); }
-	override void visit(const Postblit postblit) { mixin (tagAndAccept!"postblit"); } override void visit(const NewAnonClassExpression newAnonClassExpression) { mixin (tagAndAccept!"newAnonClassExpression"); }
-	override void visit(const PragmaDeclaration pragmaDeclaration) { mixin (tagAndAccept!"pragmaDeclaration"); }
-	override void visit(const PragmaExpression pragmaExpression) { mixin (tagAndAccept!"pragmaExpression"); }
-	override void visit(const PrimaryExpression primaryExpression) { mixin (tagAndAccept!"primaryExpression"); }
-	override void visit(const Register register) { mixin (tagAndAccept!"register"); }
-	override void visit(const ScopeGuardStatement scopeGuardStatement) { mixin (tagAndAccept!"scopeGuardStatement"); }
-	override void visit(const SharedStaticConstructor sharedStaticConstructor) { mixin (tagAndAccept!"sharedStaticConstructor"); }
-	override void visit(const SharedStaticDestructor sharedStaticDestructor) { mixin (tagAndAccept!"sharedStaticDestructor"); }
-	override void visit(const StatementNoCaseNoDefault statementNoCaseNoDefault) { mixin (tagAndAccept!"statementNoCaseNoDefault"); }
-	override void visit(const StaticAssertDeclaration staticAssertDeclaration) { mixin (tagAndAccept!"staticAssertDeclaration"); }
-	override void visit(const StaticAssertStatement staticAssertStatement) { mixin (tagAndAccept!"staticAssertStatement"); }
-	override void visit(const StaticConstructor staticConstructor) { mixin (tagAndAccept!"staticConstructor"); }
-	override void visit(const StaticDestructor staticDestructor) { mixin (tagAndAccept!"staticDestructor"); }
-	override void visit(const StaticIfCondition staticIfCondition) { mixin (tagAndAccept!"staticIfCondition"); }
-	override void visit(const StorageClass storageClass) { mixin (tagAndAccept!"storageClass"); }
-	override void visit(const StructBody structBody) { mixin (tagAndAccept!"structBody"); }
-	override void visit(const StructInitializer structInitializer) { mixin (tagAndAccept!"structInitializer"); }
-	override void visit(const StructMemberInitializers structMemberInitializers) { mixin (tagAndAccept!"structMemberInitializers"); }
-	override void visit(const StructMemberInitializer structMemberInitializer) { mixin (tagAndAccept!"structMemberInitializer"); }
-	override void visit(const SwitchStatement switchStatement) { mixin (tagAndAccept!"switchStatement"); }
-	override void visit(const Symbol symbol) { mixin (tagAndAccept!"symbol"); }
-	override void visit(const SynchronizedStatement synchronizedStatement) { mixin (tagAndAccept!"synchronizedStatement"); } override void visit(const Statement statement) { mixin (tagAndAccept!"statement"); }
-	override void visit(const TemplateArgumentList templateArgumentList) { mixin (tagAndAccept!"templateArgumentList"); }
-	override void visit(const TemplateArguments templateArguments) { mixin (tagAndAccept!"templateArguments"); }
-	override void visit(const TemplateArgument templateArgument) { mixin (tagAndAccept!"templateArgument"); }
-	override void visit(const TemplateMixinExpression templateMixinExpression) { mixin (tagAndAccept!"templateMixinExpression"); }
-	override void visit(const TemplateParameterList templateParameterList) { mixin (tagAndAccept!"templateParameterList"); }
-	override void visit(const TemplateParameters templateParameters) { mixin (tagAndAccept!"templateParameters"); }
-	override void visit(const TemplateParameter templateParameter) { mixin (tagAndAccept!"templateParameter"); }
-	override void visit(const TemplateSingleArgument templateSingleArgument) { mixin (tagAndAccept!"templateSingleArgument"); }
-	override void visit(const TemplateThisParameter templateThisParameter) { mixin (tagAndAccept!"templateThisParameter"); }
-	override void visit(const TemplateTupleParameter templateTupleParameter) { mixin (tagAndAccept!"templateTupleParameter"); }
-	override void visit(const TemplateTypeParameter templateTypeParameter) { mixin (tagAndAccept!"templateTypeParameter"); }
-	override void visit(const TemplateValueParameterDefault templateValueParameterDefault) { mixin (tagAndAccept!"templateValueParameterDefault"); }
-	override void visit(const TemplateValueParameter templateValueParameter) { mixin (tagAndAccept!"templateValueParameter"); }
-	override void visit(const TernaryExpression ternaryExpression) { mixin (tagAndAccept!"ternaryExpression"); }
-	override void visit(const ThrowStatement throwStatement) { mixin (tagAndAccept!"throwStatement"); }
-	override void visit(const TryStatement tryStatement) { mixin (tagAndAccept!"tryStatement"); } override void visit(const TemplateInstance templateInstance) { mixin (tagAndAccept!"templateInstance"); }
-	override void visit(const TypeofExpression typeofExpression) { mixin (tagAndAccept!"typeofExpression"); } override void visit(const TypeSpecialization typeSpecialization) { mixin (tagAndAccept!"typeSpecialization"); } override void visit(const TraitsExpression traitsExpression) { mixin (tagAndAccept!"traitsExpression"); }
-	override void visit(const Vector vector) { mixin (tagAndAccept!"vector"); }
-	override void visit(const VersionCondition versionCondition) { mixin (tagAndAccept!"versionCondition"); }
-	override void visit(const VersionSpecification versionSpecification) { mixin (tagAndAccept!"versionSpecification"); }
-	override void visit(const WhileStatement whileStatement) { mixin (tagAndAccept!"whileStatement"); }
-	override void visit(const WithStatement withStatement) { mixin (tagAndAccept!"withStatement"); } override void visit(const TypeidExpression typeidExpression) { mixin (tagAndAccept!"typeidExpression"); }
+    override void visit(const AliasInitializer aliasInitializer) { mixin (tagAndAccept!"aliasInitializer"); }
+    override void visit(const AliasThisDeclaration aliasThisDeclaration) { mixin (tagAndAccept!"aliasThisDeclaration"); }
+    override void visit(const ArgumentList argumentList) { mixin (tagAndAccept!"argumentList"); }
+    override void visit(const Arguments arguments) { mixin (tagAndAccept!"arguments"); }
+    override void visit(const ArrayInitializer arrayInitializer) { mixin (tagAndAccept!"arrayInitializer"); }
+    override void visit(const ArrayLiteral arrayLiteral) { mixin (tagAndAccept!"arrayLiteral"); }
+    override void visit(const ArrayMemberInitialization arrayMemberInitialization) { mixin (tagAndAccept!"arrayMemberInitialization"); }
+    override void visit(const AsmAddExp asmAddExp) { mixin (tagAndAccept!"asmAddExp"); }
+    override void visit(const AsmAndExp asmAndExp) { mixin (tagAndAccept!"asmAndExp"); }
+    override void visit(const AsmBrExp asmBrExp) { mixin (tagAndAccept!"asmBrExp"); }
+    override void visit(const AsmEqualExp asmEqualExp) { mixin (tagAndAccept!"asmEqualExp"); }
+    override void visit(const AsmExp asmExp) { mixin (tagAndAccept!"asmExp"); }
+    override void visit(const AsmLogAndExp asmLogAndExp) { mixin (tagAndAccept!"asmLogAndExp"); }
+    override void visit(const AsmLogOrExp asmLogOrExp) { mixin (tagAndAccept!"asmLogOrExp"); }
+    override void visit(const AsmMulExp asmMulExp) { mixin (tagAndAccept!"asmMulExp"); }
+    override void visit(const AsmOrExp asmOrExp) { mixin (tagAndAccept!"asmOrExp"); }
+    override void visit(const AsmPrimaryExp asmPrimaryExp) { mixin (tagAndAccept!"asmPrimaryExp"); }
+    override void visit(const AsmRelExp asmRelExp) { mixin (tagAndAccept!"asmRelExp"); }
+    override void visit(const AsmShiftExp asmShiftExp) { mixin (tagAndAccept!"asmShiftExp"); }
+    override void visit(const AsmStatement asmStatement) { mixin (tagAndAccept!"asmStatement"); }
+    override void visit(const AsmTypePrefix asmTypePrefix) { mixin (tagAndAccept!"asmTypePrefix"); }
+    override void visit(const AsmUnaExp asmUnaExp) { mixin (tagAndAccept!"asmUnaExp"); }
+    override void visit(const AsmXorExp asmXorExp) { mixin (tagAndAccept!"asmXorExp"); }
+    override void visit(const AssocArrayLiteral assocArrayLiteral) { mixin (tagAndAccept!"assocArrayLiteral"); }
+    override void visit(const AttributeDeclaration attributeDeclaration) { mixin (tagAndAccept!"attributeDeclaration"); }
+    override void visit(const BaseClass baseClass) { mixin (tagAndAccept!"baseClass"); }
+    override void visit(const BaseClassList baseClassList) { mixin (tagAndAccept!"baseClassList"); }
+    override void visit(const BlockStatement blockStatement) { mixin (tagAndAccept!"blockStatement"); }
+    override void visit(const BodyStatement bodyStatement) { mixin (tagAndAccept!"bodyStatement"); }
+    override void visit(const CaseStatement caseStatement) { mixin (tagAndAccept!"caseStatement"); }
+    override void visit(const CastExpression castExpression) { mixin (tagAndAccept!"castExpression"); }
+    override void visit(const CastQualifier castQualifier) { mixin (tagAndAccept!"castQualifier"); }
+    override void visit(const Catches catches) { mixin (tagAndAccept!"catches"); }
+    override void visit(const CmpExpression cmpExpression) { mixin (tagAndAccept!"cmpExpression"); }
+    override void visit(const CompileCondition compileCondition) { mixin (tagAndAccept!"compileCondition"); }
+    override void visit(const Constraint constraint) { mixin (tagAndAccept!"constraint"); }
+    override void visit(const Constructor constructor) { mixin (tagAndAccept!"constructor"); }
+    override void visit(const Declaration declaration) { mixin (tagAndAccept!"declaration"); }
+    override void visit(const DeclarationOrStatement declarationOrStatement) { mixin (tagAndAccept!"declarationOrStatement"); }
+    override void visit(const DeclarationsAndStatements declarationsAndStatements) { mixin (tagAndAccept!"declarationsAndStatements"); }
+    override void visit(const DefaultStatement defaultStatement) { mixin (tagAndAccept!"defaultStatement"); }
+    override void visit(const DeleteExpression deleteExpression) { mixin (tagAndAccept!"deleteExpression"); }
+    override void visit(const DeleteStatement deleteStatement) { mixin (tagAndAccept!"deleteStatement"); }
+    override void visit(const Destructor destructor) { mixin (tagAndAccept!"destructor"); }
+    override void visit(const DoStatement doStatement) { mixin (tagAndAccept!"doStatement"); }
+    override void visit(const EnumBody enumBody) { mixin (tagAndAccept!"enumBody"); }
+    override void visit(const EponymousTemplateDeclaration eponymousTemplateDeclaration) { mixin (tagAndAccept!"eponymousTemplateDeclaration"); }
+    override void visit(const Expression expression) { mixin (tagAndAccept!"expression"); }
+    override void visit(const ExpressionStatement expressionStatement) { mixin (tagAndAccept!"expressionStatement"); }
+    override void visit(const FinalSwitchStatement finalSwitchStatement) { mixin (tagAndAccept!"finalSwitchStatement"); }
+    override void visit(const ForeachTypeList foreachTypeList) { mixin (tagAndAccept!"foreachTypeList"); }
+    override void visit(const FunctionAttribute functionAttribute) { mixin (tagAndAccept!"functionAttribute"); }
+    override void visit(const FunctionBody functionBody) { mixin (tagAndAccept!"functionBody"); }
+    override void visit(const FunctionCallExpression functionCallExpression) { mixin (tagAndAccept!"functionCallExpression"); }
+    override void visit(const IdentifierChain identifierChain) { mixin (tagAndAccept!"identifierChain"); }
+    override void visit(const IdentifierList identifierList) { mixin (tagAndAccept!"identifierList"); }
+    override void visit(const IdentifierOrTemplateChain identifierOrTemplateChain) { mixin (tagAndAccept!"identifierOrTemplateChain"); }
+    override void visit(const IdentifierOrTemplateInstance identifierOrTemplateInstance) { mixin (tagAndAccept!"identifierOrTemplateInstance"); }
+    override void visit(const ImportBindings importBindings) { mixin (tagAndAccept!"importBindings"); }
+    override void visit(const ImportDeclaration importDeclaration) { mixin (tagAndAccept!"importDeclaration"); }
+    override void visit(const ImportExpression importExpression) { mixin (tagAndAccept!"importExpression"); }
+    override void visit(const IndexExpression indexExpression) { mixin (tagAndAccept!"indexExpression"); }
+    override void visit(const InStatement inStatement) { mixin (tagAndAccept!"inStatement"); }
+    override void visit(const KeyValuePairs keyValuePairs) { mixin (tagAndAccept!"keyValuePairs"); }
+    override void visit(const MixinExpression mixinExpression) { mixin (tagAndAccept!"mixinExpression"); }
+    override void visit(const MixinTemplateDeclaration mixinTemplateDeclaration) { mixin (tagAndAccept!"mixinTemplateDeclaration"); }
+    override void visit(const MixinTemplateName mixinTemplateName) { mixin (tagAndAccept!"mixinTemplateName"); }
+    override void visit(const ModuleDeclaration moduleDeclaration) { mixin (tagAndAccept!"moduleDeclaration"); }
+    override void visit(const LastCatch lastCatch) { mixin (tagAndAccept!"lastCatch"); }
+    override void visit(const NewExpression newExpression) { mixin (tagAndAccept!"newExpression"); }
+    override void visit(const NonVoidInitializer nonVoidInitializer) { mixin (tagAndAccept!"nonVoidInitializer"); }
+    override void visit(const Operands operands) { mixin (tagAndAccept!"operands"); }
+    override void visit(const OrExpression orExpression) { mixin (tagAndAccept!"orExpression"); }
+    override void visit(const OutStatement outStatement) { mixin (tagAndAccept!"outStatement"); } override void visit(const MixinDeclaration mixinDeclaration) { mixin (tagAndAccept!"mixinDeclaration"); }
+    override void visit(const Parameters parameters) { mixin (tagAndAccept!"parameters"); }
+    override void visit(const Postblit postblit) { mixin (tagAndAccept!"postblit"); } override void visit(const NewAnonClassExpression newAnonClassExpression) { mixin (tagAndAccept!"newAnonClassExpression"); }
+    override void visit(const PragmaDeclaration pragmaDeclaration) { mixin (tagAndAccept!"pragmaDeclaration"); }
+    override void visit(const PragmaExpression pragmaExpression) { mixin (tagAndAccept!"pragmaExpression"); }
+    override void visit(const PrimaryExpression primaryExpression) { mixin (tagAndAccept!"primaryExpression"); }
+    override void visit(const Register register) { mixin (tagAndAccept!"register"); }
+    override void visit(const ScopeGuardStatement scopeGuardStatement) { mixin (tagAndAccept!"scopeGuardStatement"); }
+    override void visit(const SharedStaticConstructor sharedStaticConstructor) { mixin (tagAndAccept!"sharedStaticConstructor"); }
+    override void visit(const SharedStaticDestructor sharedStaticDestructor) { mixin (tagAndAccept!"sharedStaticDestructor"); }
+    override void visit(const StatementNoCaseNoDefault statementNoCaseNoDefault) { mixin (tagAndAccept!"statementNoCaseNoDefault"); }
+    override void visit(const StaticAssertDeclaration staticAssertDeclaration) { mixin (tagAndAccept!"staticAssertDeclaration"); }
+    override void visit(const StaticAssertStatement staticAssertStatement) { mixin (tagAndAccept!"staticAssertStatement"); }
+    override void visit(const StaticConstructor staticConstructor) { mixin (tagAndAccept!"staticConstructor"); }
+    override void visit(const StaticDestructor staticDestructor) { mixin (tagAndAccept!"staticDestructor"); }
+    override void visit(const StaticIfCondition staticIfCondition) { mixin (tagAndAccept!"staticIfCondition"); }
+    override void visit(const StorageClass storageClass) { mixin (tagAndAccept!"storageClass"); }
+    override void visit(const StructBody structBody) { mixin (tagAndAccept!"structBody"); }
+    override void visit(const StructInitializer structInitializer) { mixin (tagAndAccept!"structInitializer"); }
+    override void visit(const StructMemberInitializers structMemberInitializers) { mixin (tagAndAccept!"structMemberInitializers"); }
+    override void visit(const StructMemberInitializer structMemberInitializer) { mixin (tagAndAccept!"structMemberInitializer"); }
+    override void visit(const SwitchStatement switchStatement) { mixin (tagAndAccept!"switchStatement"); }
+    override void visit(const Symbol symbol) { mixin (tagAndAccept!"symbol"); }
+    override void visit(const SynchronizedStatement synchronizedStatement) { mixin (tagAndAccept!"synchronizedStatement"); } override void visit(const Statement statement) { mixin (tagAndAccept!"statement"); }
+    override void visit(const TemplateArgumentList templateArgumentList) { mixin (tagAndAccept!"templateArgumentList"); }
+    override void visit(const TemplateArguments templateArguments) { mixin (tagAndAccept!"templateArguments"); }
+    override void visit(const TemplateArgument templateArgument) { mixin (tagAndAccept!"templateArgument"); }
+    override void visit(const TemplateMixinExpression templateMixinExpression) { mixin (tagAndAccept!"templateMixinExpression"); }
+    override void visit(const TemplateParameterList templateParameterList) { mixin (tagAndAccept!"templateParameterList"); }
+    override void visit(const TemplateParameters templateParameters) { mixin (tagAndAccept!"templateParameters"); }
+    override void visit(const TemplateParameter templateParameter) { mixin (tagAndAccept!"templateParameter"); }
+    override void visit(const TemplateSingleArgument templateSingleArgument) { mixin (tagAndAccept!"templateSingleArgument"); }
+    override void visit(const TemplateThisParameter templateThisParameter) { mixin (tagAndAccept!"templateThisParameter"); }
+    override void visit(const TemplateTupleParameter templateTupleParameter) { mixin (tagAndAccept!"templateTupleParameter"); }
+    override void visit(const TemplateTypeParameter templateTypeParameter) { mixin (tagAndAccept!"templateTypeParameter"); }
+    override void visit(const TemplateValueParameterDefault templateValueParameterDefault) { mixin (tagAndAccept!"templateValueParameterDefault"); }
+    override void visit(const TemplateValueParameter templateValueParameter) { mixin (tagAndAccept!"templateValueParameter"); }
+    override void visit(const TernaryExpression ternaryExpression) { mixin (tagAndAccept!"ternaryExpression"); }
+    override void visit(const ThrowStatement throwStatement) { mixin (tagAndAccept!"throwStatement"); }
+    override void visit(const TryStatement tryStatement) { mixin (tagAndAccept!"tryStatement"); } override void visit(const TemplateInstance templateInstance) { mixin (tagAndAccept!"templateInstance"); }
+    override void visit(const TypeofExpression typeofExpression) { mixin (tagAndAccept!"typeofExpression"); } override void visit(const TypeSpecialization typeSpecialization) { mixin (tagAndAccept!"typeSpecialization"); } override void visit(const TraitsExpression traitsExpression) { mixin (tagAndAccept!"traitsExpression"); }
+    override void visit(const Vector vector) { mixin (tagAndAccept!"vector"); }
+    override void visit(const VersionCondition versionCondition) { mixin (tagAndAccept!"versionCondition"); }
+    override void visit(const VersionSpecification versionSpecification) { mixin (tagAndAccept!"versionSpecification"); }
+    override void visit(const WhileStatement whileStatement) { mixin (tagAndAccept!"whileStatement"); }
+    override void visit(const WithStatement withStatement) { mixin (tagAndAccept!"withStatement"); } override void visit(const TypeidExpression typeidExpression) { mixin (tagAndAccept!"typeidExpression"); }
 
-	alias visit = ASTVisitor.visit;
+    alias visit = ASTVisitor.visit;
 
-	private static string xmlEscape(string s)
-	{
-		return s.translate(['<' : "&lt;", '>' : "&gt;", '&' : "&amp;"]);
-	}
+    private static string xmlEscape(string s)
+    {
+        return s.translate(['<' : "&lt;", '>' : "&gt;", '&' : "&amp;"]);
+    }
 
-	private static string xmlAttributeEscape(string s)
-	{
-		return s.translate(['<' : "&lt;", '>' : "&gt;", '&' : "&amp;",
-			'\"' : "&quot;", '\'' : "&apos;"]);
-	}
+    private static string xmlAttributeEscape(string s)
+    {
+        return s.translate(['<' : "&lt;", '>' : "&gt;", '&' : "&amp;",
+            '\"' : "&quot;", '\'' : "&apos;"]);
+    }
 
     private void writeDdoc(string comment)
     {
@@ -1120,6 +1094,6 @@ class XMLPrinter : ASTVisitor
         output.writeln("<ddoc>", xmlEscape(comment), "</ddoc>");
     }
 
-	File output;
+    File output;
 }
 
diff --git a/src/ctags.d b/src/ctags.d
index 9172352..8a896e4 100644
--- a/src/ctags.d
+++ b/src/ctags.d
@@ -72,9 +72,7 @@ class CTagsPrinter : ASTVisitor
 
 	override void visit(const TemplateDeclaration dec)
 	{
-		auto name = dec.eponymousTemplateDeclaration is null ? dec.name
-			: dec.eponymousTemplateDeclaration.name;
-		tagLines ~= "%s\t%s\t%d;\"\tT%s\n".format(name.text, fileName, name.line, context);
+		tagLines ~= "%s\t%s\t%d;\"\tT%s\n".format(dec.name.text, fileName, dec.name.line, context);
 		auto c = context;
 		context = "\ttemplate:" ~ dec.name.text;
 		dec.accept(this);
diff --git a/src/main.d b/src/main.d
index 0c16233..b3ba04e 100644
--- a/src/main.d
+++ b/src/main.d
@@ -175,7 +175,7 @@ int run(string[] args)
 	}
 	else if (syntaxCheck)
 	{
-		.syntaxCheck(expandArgs(args));
+		return .syntaxCheck(expandArgs(args));
 	}
 	else
 	{