From 8a7c962d16e1c3c7e9413fe6059c62c2205dc43f Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Wed, 22 May 2013 23:50:23 -0700
Subject: [PATCH] Parser implementation work

---
 std/d/ast.d    |    1 +
 std/d/parser.d | 1752 ++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 1480 insertions(+), 273 deletions(-)

diff --git a/std/d/ast.d b/std/d/ast.d
index 452979e..79b4b5e 100755
--- a/std/d/ast.d
+++ b/std/d/ast.d
@@ -1159,6 +1159,7 @@ class LabeledStatement : ASTNode
 {
 public:
 	mixin(DEFAULT_ACCEPT);
+    Token identifier;
 	Statement statement;
 }
 
diff --git a/std/d/parser.d b/std/d/parser.d
index 85b571b..554a1e4 100755
--- a/std/d/parser.d
+++ b/std/d/parser.d
@@ -21,61 +21,302 @@ private:
 
 struct Parser
 {
-	AddExpression parseAddExpression() { return null; }
-	AliasDeclaration parseAliasDeclaration() { return null; }
-	AliasInitializer parseAliasInitializer() { return null; }
-	AliasThisDeclaration parseAliasThisDeclaration() { return null; }
-	AlignAttribute parseAlignAttribute() { return null; }
-	AndAndExpression parseAndAndExpression() { return null; }
-	AndExpression parseAndExpression() { return null; }
-	ArgumentList parseArgumentList() { return null; }
-	Arguments parseArguments() { return null; }
-	ArrayInitializer parseArrayInitializer() { return null; }
-	ArrayLiteral parseArrayLiteral() { return null; }
-	ArrayMemberInitialization parseArrayMemberInitialization() { return null; }
-	ArrayMemberInitializations parseArrayMemberInitializations() { return null; }
-	AsmAddExp parseAsmAddExp() { return null; }
-	AsmAndExp parseAsmAndExp() { return null; }
-	AsmBrExp parseAsmBrExp() { return null; }
-	AsmEqualExp parseAsmEqualExp() { return null; }
-	AsmExp parseAsmExp() { return null; }
-	AsmInstruction parseAsmInstruction() { return null; }
-	AsmLogAndExp parseAsmLogAndExp() { return null; }
-	AsmLogOrExp parseAsmLogOrExp() { return null; }
-	AsmMulExp parseAsmMulExp() { return null; }
-	AsmOrExp parseAsmOrExp() { return null; }
-	AsmPrimaryExp parseAsmPrimaryExp() { return null; }
-	AsmRelExp parseAsmRelExp() { return null; }
-	AsmShiftExp parseAsmShiftExp() { return null; }
-	AsmStatement parseAsmStatement() { return null; }
-	AsmTypePrefix parseAsmTypePrefix() { return null; }
-	AsmUnaExp parseAsmUnaExp() { return null; }
-	AsmXorExp parseAsmXorExp() { return null; }
-	AssertExpression parseAssertExpression() { return null; }
-	AssertStatement parseAssertStatement() { return null; }
-	AssignExpression parseAssignExpression() { return null; }
-	AssignStatement parseAssignStatement() { return null; }
-	AssocArrayLiteral parseAssocArrayLiteral() { return null; }
-	AtAttribute parseAtAttribute() { return null; }
-	Attribute parseAttribute() { return null; }
-	AttributedDeclaration parseAttributedDeclaration() { return null; }
-	AutoDeclaration parseAutoDeclaration() { return null; }
+	AddExpression parseAddExpression()
+    {
+        auto node = new AddExpression;
+        return node;
+    }
+
+	AliasDeclaration parseAliasDeclaration()
+    {
+        auto node = new AliasDeclaration;
+
+        return node;
+    }
+
+    AliasInitializer parseAliasInitializer()
+    {
+        auto node = new AliasInitializer;
+
+        return node;
+    }
+
+	AliasThisDeclaration parseAliasThisDeclaration()
+    {
+        auto node = new AliasThisDeclaration;
+
+        return node;
+    }
+
+	AlignAttribute parseAlignAttribute()
+    {
+        auto node = new AlignAttribute;
+
+        return node;
+    }
+
+	AndAndExpression parseAndAndExpression()
+    {
+        auto node = new AndAndExpression;
+
+        return node;
+    }
+
+	AndExpression parseAndExpression()
+    {
+        auto node = new AndExpression;
+
+        return node;
+    }
+
+	ArgumentList parseArgumentList()
+    {
+        auto node = new ArgumentList;
+
+        return node;
+    }
+
+	Arguments parseArguments()
+    {
+        auto node = new Arguments;
+        expect(TokenType.lParen);
+        node.argumentList = parseArgumentList();
+        expect(TokenType.rParen);
+        return node;
+    }
+
+	ArrayInitializer parseArrayInitializer()
+    {
+        auto node = new ArrayInitializer;
+
+        return node;
+    }
+
+    ArrayLiteral parseArrayLiteral()
+    {
+        auto node = new ArrayLiteral;
+        expect(TokenType.lBracket);
+        node.argumentList = parseArgumentList();
+        expect(TokenType.rBracket);
+        return node;
+    }
+
+	ArrayMemberInitialization parseArrayMemberInitialization()
+    {
+        auto node = new ArrayMemberInitialization;
+
+        return node;
+    }
+
+	ArrayMemberInitializations parseArrayMemberInitializations()
+    {
+        auto node = new ArrayMemberInitializations;
+
+        return node;
+    }
+
+	AsmAddExp parseAsmAddExp()
+    {
+        auto node = new AsmAddExp;
+
+        return node;
+    }
+
+	AsmAndExp parseAsmAndExp()
+    {
+        auto node = new AsmAndExp;
+
+        return node;
+    }
+
+	AsmBrExp parseAsmBrExp()
+    {
+        auto node = new AsmBrExp;
+
+        return node;
+    }
+
+	AsmEqualExp parseAsmEqualExp()
+    {
+        auto node = new AsmEqualExp;
+
+        return node;
+    }
+
+	AsmExp parseAsmExp()
+    {
+        auto node = new AsmExp;
+
+        return node;
+    }
+
+	AsmInstruction parseAsmInstruction()
+    {
+        auto node = new AsmInstruction;
+
+        return node;
+    }
+
+	AsmLogAndExp parseAsmLogAndExp()
+    {
+        auto node = new AsmLogAndExp;
+
+        return node;
+    }
+
+	AsmLogOrExp parseAsmLogOrExp()
+    {
+        auto node = new AsmLogOrExp;
+
+        return node;
+    }
+
+	AsmMulExp parseAsmMulExp()
+    {
+        auto node = new AsmMulExp;
+
+        return node;
+    }
+
+	AsmOrExp parseAsmOrExp()
+    {
+        auto node = new AsmOrExp;
+
+        return node;
+    }
+
+	AsmPrimaryExp parseAsmPrimaryExp()
+    {
+        auto node = new AsmPrimaryExp;
+
+        return node;
+    }
+
+	AsmRelExp parseAsmRelExp()
+    {
+        auto node = new AsmRelExp;
+
+        return node;
+    }
+
+	AsmShiftExp parseAsmShiftExp()
+    {
+        auto node = new AsmShiftExp;
+
+        return node;
+    }
+
+	AsmStatement parseAsmStatement()
+    {
+        auto node = new AsmStatement;
+
+        return node;
+    }
+
+	AsmTypePrefix parseAsmTypePrefix()
+    {
+        auto node = new AsmTypePrefix;
+
+        return node;
+    }
+
+	AsmUnaExp parseAsmUnaExp()
+    {
+        auto node = new AsmUnaExp;
+
+        return node;
+    }
+
+	AsmXorExp parseAsmXorExp()
+    {
+        auto node = new AsmXorExp;
+
+        return node;
+    }
+
+	AssertExpression parseAssertExpression()
+    {
+        auto node = new AssertExpression;
+
+        return node;
+    }
+
+	AssertStatement parseAssertStatement()
+    {
+        auto node = new AssertStatement;
+
+        return node;
+    }
+
+	AssignExpression parseAssignExpression()
+    {
+        auto node = new AssignExpression;
+
+        return node;
+    }
+
+	AssignStatement parseAssignStatement()
+    {
+        auto node = new AssignStatement;
+
+        return node;
+    }
+
+	AssocArrayLiteral parseAssocArrayLiteral()
+    {
+        auto node = new AssocArrayLiteral;
+
+        return node;
+    }
+
+	AtAttribute parseAtAttribute()
+    {
+        auto node = new AtAttribute;
+
+        return node;
+    }
+
+	Attribute parseAttribute()
+    {
+        auto node = new Attribute;
+
+        return node;
+    }
+
+	AttributedDeclaration parseAttributedDeclaration()
+    {
+        auto node = new AttributedDeclaration;
+
+        return node;
+    }
+
+	AutoDeclaration parseAutoDeclaration()
+    {
+        auto node = new AutoDeclaration;
+
+        return node;
+    }
 
 	BlockStatement parseBlockStatement()
 	{
-		auto statement = new BlockStatement();
+		auto node = new BlockStatement();
 		expect(TokenType.lBrace);
 		switch (tokens[index].type)
 		{
 		case TokenType.rBrace:
 			break;
 		default:
-			statement.statements ~= parseStatement();
+			node.declarationsAndStatements = parseDeclarationsAndStatements();
 		}
-		return statement;
+		return node;
 	}
 
-	BodyStatement parseBodyStatement() { return null; }
+	BodyStatement parseBodyStatement()
+    {
+        auto node = new BodyStatement;
+
+        return node;
+    }
 
 	BreakStatement parseBreakStatement()
 	{
@@ -83,21 +324,110 @@ struct Parser
 		return parseContinueBreakStatement!(BreakStatement)();
 	}
 
-	BuiltinType parseBuiltinType() { return null; }
-	CaseRangeStatement parseCaseRangeStatement() { return null; }
-	CaseStatement parseCaseStatement() { return null; }
-	CastExpression parseCastExpression() { return null; }
-	CastQualifier parseCastQualifier() { return null; }
-	Catch parseCatch() { return null; }
-	Catches parseCatches() { return null; }
-	ClassBody parseClassBody() { return null; }
-	ClassDeclaration parseClassDeclaration() { return null; }
-	CmpExpression parseCmpExpression() { return null; }
-	CompileCondition parseCompileCondition() { return null; }
-	ConditionalDeclaration parseConditionalDeclaration() { return null; }
-	ConditionalStatement parseConditionalStatement() { return null; }
-	Constraint parseConstraint() { return null; }
-	Constructor parseConstructor() { return null; }
+	BuiltinType parseBuiltinType()
+    {
+        auto node = new BuiltinType;
+
+        return node;
+    }
+
+	CaseRangeStatement parseCaseRangeStatement()
+    {
+        auto node = new CaseRangeStatement;
+
+        return node;
+    }
+
+	CaseStatement parseCaseStatement()
+    {
+        auto node = new CaseStatement;
+
+        return node;
+    }
+
+	CastExpression parseCastExpression()
+    {
+        auto node = new CastExpression;
+
+        return node;
+    }
+
+	CastQualifier parseCastQualifier()
+    {
+        auto node = new CastQualifier;
+
+        return node;
+    }
+
+	Catch parseCatch()
+    {
+        auto node = new Catch;
+
+        return node;
+    }
+
+	Catches parseCatches()
+    {
+        auto node = new Catches;
+
+        return node;
+    }
+
+	ClassBody parseClassBody()
+    {
+        auto node = new ClassBody;
+
+        return node;
+    }
+
+	ClassDeclaration parseClassDeclaration()
+    {
+        auto node = new ClassDeclaration;
+
+        return node;
+    }
+
+	CmpExpression parseCmpExpression()
+    {
+        auto node = new CmpExpression;
+
+        return node;
+    }
+
+	CompileCondition parseCompileCondition()
+    {
+        auto node = new CompileCondition;
+
+        return node;
+    }
+
+	ConditionalDeclaration parseConditionalDeclaration()
+    {
+        auto node = new ConditionalDeclaration;
+
+        return node;
+    }
+
+	ConditionalStatement parseConditionalStatement()
+    {
+        auto node = new ConditionalStatement;
+
+        return node;
+    }
+
+	Constraint parseConstraint()
+    {
+        auto node = new Constraint;
+
+        return node;
+    }
+
+	Constructor parseConstructor()
+    {
+        auto node = new Constructor;
+
+        return node;
+    }
 
 	ContinueStatement parseContinueStatement()
 	{
@@ -105,70 +435,277 @@ struct Parser
 		return parseContinueBreakStatement!(ContinueStatement)();
 	}
 
-	DebugCondition parseDebugCondition() { return null; }
-	DebugSpecification parseDebugSpecification() { return null; }
-	Declaration parseDeclaration() { return null; }
-	DeclarationsAndStatements parseDeclarationsAndStatements() { return null; }
-	Declarator parseDeclarator() { return null; }
-	DeclaratorSuffix parseDeclaratorSuffix() { return null; }
-	DefaultStatement parseDefaultStatement() { return null; }
-	DeleteExpression parseDeleteExpression() { return null; }
-	DeleteStatement parseDeleteStatement() { return null; }
-	Deprecated parseDeprecated() { return null; }
-	Destructor parseDestructor() { return null; }
-	DoStatement parseDoStatement() { return null; }
-	EnumBody parseEnumBody() { return null; }
-	EnumDeclaration parseEnumDeclaration() { return null; }
-	EnumMember parseEnumMember() { return null; }
-	EqualExpression parseEqualExpression() { return null; }
-	Expression parseExpression() { return null; }
-	FinalSwitchStatement parseFinalSwitchStatement() { return null; }
-	Finally parseFinally() { return null; }
-	ForStatement parseForStatement() { return null; }
-	ForeachRangeStatement parseForeachRangeStatement() { return null; }
-	ForeachStatement parseForeachStatement() { return null; }
-	ForeachType parseForeachType() { return null; }
-	ForeachTypeList parseForeachTypeList() { return null; }
-	FunctionAttribute parseFunctionAttribute() { return null; }
-	FunctionBody parseFunctionBody() { return null; }
-	FunctionCallExpression parseFunctionCallExpression() { return null; }
-	FunctionCallStatement parseFunctionCallStatement() { return null; }
-	FunctionDeclaration parseFunctionDeclaration() { return null; }
-	FunctionLiteralExpression parseFunctionLiteralExpression() { return null; }
+	DebugCondition parseDebugCondition()
+    {
+        auto node = new DebugCondition;
+
+        return node;
+    }
+
+	DebugSpecification parseDebugSpecification()
+    {
+        auto node = new DebugSpecification;
+
+        return node;
+    }
+
+	Declaration parseDeclaration()
+    {
+        auto node = new Declaration;
+
+        return node;
+    }
+
+	DeclarationsAndStatements parseDeclarationsAndStatements()
+    {
+        auto node = new DeclarationsAndStatements;
+
+        return node;
+    }
+
+	Declarator parseDeclarator()
+    {
+        auto node = new Declarator;
+
+        return node;
+    }
+
+	DeclaratorSuffix parseDeclaratorSuffix()
+    {
+        auto node = new DeclaratorSuffix;
+
+        return node;
+    }
+
+	DefaultStatement parseDefaultStatement()
+    {
+        auto node = new DefaultStatement;
+
+        return node;
+    }
+
+	DeleteExpression parseDeleteExpression()
+    {
+        auto node = new DeleteExpression;
+
+        return node;
+    }
+
+	DeleteStatement parseDeleteStatement()
+    {
+        auto node = new DeleteStatement;
+
+        return node;
+    }
+
+	Deprecated parseDeprecated()
+    {
+        auto node = new Deprecated;
+
+        return node;
+    }
+
+	Destructor parseDestructor()
+    {
+        auto node = new Destructor;
+
+        return node;
+    }
+
+	DoStatement parseDoStatement()
+    {
+        auto node = new DoStatement;
+
+        return node;
+    }
+
+	EnumBody parseEnumBody()
+    {
+        auto node = new EnumBody;
+
+        return node;
+    }
+
+	EnumDeclaration parseEnumDeclaration()
+    {
+        auto node = new EnumDeclaration;
+
+        return node;
+    }
+
+	EnumMember parseEnumMember()
+    {
+        auto node = new EnumMember;
+
+        return node;
+    }
+
+	EqualExpression parseEqualExpression()
+    {
+        auto node = new EqualExpression;
+
+        return node;
+    }
+
+	Expression parseExpression()
+    {
+        auto node = new Expression;
+
+        return node;
+    }
+
+	FinalSwitchStatement parseFinalSwitchStatement()
+    {
+        auto node = new FinalSwitchStatement;
+
+        return node;
+    }
+
+	Finally parseFinally()
+    {
+        auto node = new Finally;
+
+        return node;
+    }
+
+	ForStatement parseForStatement()
+    {
+        auto node = new ForStatement;
+
+        return node;
+    }
+
+	ForeachRangeStatement parseForeachRangeStatement()
+    {
+        auto node = new ForeachRangeStatement;
+
+        return node;
+    }
+
+	ForeachStatement parseForeachStatement()
+    {
+        auto node = new ForeachStatement;
+
+        return node;
+    }
+
+	ForeachType parseForeachType()
+    {
+        auto node = new ForeachType;
+
+        return node;
+    }
+
+	ForeachTypeList parseForeachTypeList()
+    {
+        auto node = new ForeachTypeList;
+
+        return node;
+    }
+
+	FunctionAttribute parseFunctionAttribute()
+    {
+        auto node = new FunctionAttribute;
+
+        return node;
+    }
+
+	FunctionBody parseFunctionBody()
+    {
+        auto node = new FunctionBody;
+
+        return node;
+    }
+
+	FunctionCallExpression parseFunctionCallExpression()
+    {
+        auto node = new FunctionCallExpression;
+
+        return node;
+    }
+
+	FunctionCallStatement parseFunctionCallStatement()
+    {
+        auto node = new FunctionCallStatement;
+
+        return node;
+    }
+
+	FunctionDeclaration parseFunctionDeclaration()
+    {
+        auto node = new FunctionDeclaration;
+
+        return node;
+    }
+
+	FunctionLiteralExpression parseFunctionLiteralExpression()
+    {
+        auto node = new FunctionLiteralExpression;
+
+        return node;
+    }
 
 	GotoStatement parseGotoStatement()
 	{
-		expect(TokenType.goto_);
-		auto g = new GotoStatement;
-		switch (tokens[index].type)
-		{
-		case TokenType.identifier:
-			g.type = GotoStatement.GotoType.identifier;
-			g.identifier = tokens[index++].value;
-			break;
-		case TokenType.default_:
-			index++;
-			g.type = GotoStatement.GotoType.default_;
-			break;
-		case TokenType.case_:
-			g.type = GotoStatement.GotoType.case_;
-			index++;
-			break;
-		default:
-			error("Expected an identifier, \"default\", or \"case\" following \"goto\"");
-			return null;
-		}
-		return g;
+		auto node = new GotoStatement;
+		return node;
 	}
 
-	IdentifierChain parseIdentifierChain() { return null; }
-	IdentifierList parseIdentifierList() { return null; }
-	IdentifierOrTemplateChain parseIdentifierOrTemplateChain() { return null; }
-	IdentifierOrTemplateInstance parseIdentifierOrTemplateInstance() { return null; }
-	IdentityExpression parseIdentityExpression() { return null; }
-	IfStatement parseIfStatement() { return null; }
-	ImportBind parseImportBind() { return null; }
-	ImportBindings parseImportBindings() { return null; }
+	IdentifierChain parseIdentifierChain()
+    {
+        auto node = new IdentifierChain;
+
+        return node;
+    }
+
+	IdentifierList parseIdentifierList()
+    {
+        auto node = new IdentifierList;
+
+        return node;
+    }
+
+	IdentifierOrTemplateChain parseIdentifierOrTemplateChain()
+    {
+        auto node = new IdentifierOrTemplateChain;
+
+        return node;
+    }
+
+	IdentifierOrTemplateInstance parseIdentifierOrTemplateInstance()
+    {
+        auto node = new IdentifierOrTemplateInstance;
+
+        return node;
+    }
+
+	IdentityExpression parseIdentityExpression()
+    {
+        auto node = new IdentityExpression;
+
+        return node;
+    }
+
+	IfStatement parseIfStatement()
+    {
+        auto node = new IfStatement;
+
+        return node;
+    }
+
+	ImportBind parseImportBind()
+    {
+        auto node = new ImportBind;
+
+        return node;
+    }
+
+	ImportBindings parseImportBindings()
+    {
+        auto node = new ImportBindings;
+
+        return node;
+    }
 
 	ImportDeclaration parseImportDeclaration(Tokens)(ref Tokens tokens)
 	in
@@ -274,38 +811,139 @@ struct Parser
 		return declaration;
 	}
 
-	ImportExpression parseImportExpression() { return null; }
-	ImportList parseImportList() { return null; }
-	InExpression parseInExpression() { return null; }
-	InStatement parseInStatement() { return null; }
-	Initialize parseInitialize() { return null; }
-	Initializer parseInitializer() { return null; }
-	InterfaceDeclaration parseInterfaceDeclaration() { return null; }
-	Invariant parseInvariant() { return null; }
-	IsExpression parseIsExpression() { return null; }
-	KeyValuePair parseKeyValuePair() { return null; }
-	KeyValuePairs parseKeyValuePairs() { return null; }
+	ImportExpression parseImportExpression()
+    {
+        auto node = new ImportExpression;
+
+        return node;
+    }
+
+	ImportList parseImportList()
+    {
+        auto node = new ImportList;
+
+        return node;
+    }
+
+	InExpression parseInExpression()
+    {
+        auto node = new InExpression;
+
+        return node;
+    }
+
+	InStatement parseInStatement()
+    {
+        auto node = new InStatement;
+
+        return node;
+    }
+
+	Initialize parseInitialize()
+    {
+        auto node = new Initialize;
+
+        return node;
+    }
+
+	Initializer parseInitializer()
+    {
+        auto node = new Initializer;
+
+        return node;
+    }
+
+	InterfaceDeclaration parseInterfaceDeclaration()
+    {
+        auto node = new InterfaceDeclaration;
+        return node;
+    }
+
+	Invariant parseInvariant()
+    {
+        auto node = new Invariant;
+
+        return node;
+    }
+
+	IsExpression parseIsExpression()
+    {
+        auto node = new IsExpression;
+
+        return node;
+    }
+
+	KeyValuePair parseKeyValuePair()
+    {
+        auto node = new KeyValuePair;
+
+        return node;
+    }
+
+	KeyValuePairs parseKeyValuePairs()
+    {
+        auto node = new KeyValuePairs;
+
+        return node;
+    }
 
 	LabeledStatement parseLabeledStatement()
-	in
 	{
-		assert (tokens[index].type == TokenType.identifier);
-	}
-	body
-	{
-		auto ls = new LabeledStatement;
-		ls.label = tokens[index++].value;
-		ls.statement = parseNoScopeStatement();
-		return ls;
+		auto node = new LabeledStatement;
+		node.identifier = *expect(TokenType.identifier);
+		expect(TokenType.colon);
+		node.statement = parseStatement();
+		return node;
 	}
 
-	LambdaExpression parseLambdaExpression() { return null; }
-	LastCatch parseLastCatch() { return null; }
-	LinkageAttribute parseLinkageAttribute() { return null; }
-	MemberFunctionAttribute parseMemberFunctionAttribute() { return null; }
-	MixinDeclaration parseMixinDeclaration() { return null; }
-	MixinExpression parseMixinExpression() { return null; }
-	MixinTemplateName parseMixinTemplateName() { return null; }
+	LambdaExpression parseLambdaExpression()
+    {
+        auto node = new LambdaExpression;
+
+        return node;
+    }
+
+	LastCatch parseLastCatch()
+    {
+        auto node = new LastCatch;
+
+        return node;
+    }
+
+	LinkageAttribute parseLinkageAttribute()
+    {
+        auto node = new LinkageAttribute;
+
+        return node;
+    }
+
+	MemberFunctionAttribute parseMemberFunctionAttribute()
+    {
+        auto node = new MemberFunctionAttribute;
+
+        return node;
+    }
+
+	MixinDeclaration parseMixinDeclaration()
+    {
+        auto node = new MixinDeclaration;
+
+        return node;
+    }
+
+	MixinExpression parseMixinExpression()
+    {
+        auto node = new MixinExpression;
+
+        return node;
+    }
+
+	MixinTemplateName parseMixinTemplateName()
+    {
+        auto node = new MixinTemplateName;
+
+        return node;
+    }
 
 	Module parseModule()
     {
@@ -315,151 +953,719 @@ struct Parser
             switch (tokens[index].type)
             {
             case TokenType.module_:
-                if (m.declaration !is null)
-                    m.declaration = parseModuleDeclaration();
+                if (m.moduleDeclaration !is null)
+                    m.moduleDeclaration = parseModuleDeclaration();
                 else
                     error("Only one module declaration is allowed per module");
                 break;
             default:
-                m.declDefs.insert(parseDeclDef());
+                m.declarations ~= parseDeclaration();
             }
         }
         return m;
     }
 
 	ModuleDeclaration parseModuleDeclaration()
-    in
     {
-        assert (expect(TokenType.module_));
-    }
-    body
-    {
-        ModuleDeclaration declaration = new ModuleDeclaration;
-        string recent;
-        loop: while (index < tokens.length)
-        {
-            if (tokens[index].type == TokenType.identifier)
-            {
-                recent = tokens[index++].value;
-                switch (tokens[index].type)
-                {
-                case TokenType.dot:
-                    declaration.packageName ~= recent;
-                    index++;
-                    break;
-                case TokenType.semicolon:
-                    declaration.moduleName = recent;
-                    index++;
-                    break loop;
-                default:
-                    break;
-                }
-            }
-            else
-                error("Identifier expected");
-        }
-        return declaration;
+        auto node = new ModuleDeclaration;
+        expect(TokenType.module_);
+        node.moduleName = parseIdentifierChain();
+        expect(TokenType.semicolon);
+        return node;
     }
 
-	MulExpression parseMulExpression() { return null; }
-	NewAnonClassExpression parseNewAnonClassExpression() { return null; }
-	NewExpression parseNewExpression() { return null; }
+	MulExpression parseMulExpression()
+    {
+        auto node = new MulExpression;
+
+        return node;
+    }
+
+	NewAnonClassExpression parseNewAnonClassExpression()
+    {
+        auto node = new NewAnonClassExpression;
+
+        return node;
+    }
+
+	NewExpression parseNewExpression()
+    {
+        auto node = new NewExpression;
+
+        return node;
+    }
 
 	NonEmptyStatement parseNonEmptyStatement()
 	{
-		switch (tokens[index].type)
-		{
-		case TokenType.case_:
-			return parseCaseStatement();
-		case TokenType.default_:
-			return parseDefaultStatement();
-		default:
-			return null;
-		}
+		auto node = new NonEmptyStatement;
+        return node;
 	}
 
-	NonEmptyStatementNoCaseNoDefault parseNonEmptyStatementNoCaseNoDefault() { return null; }
-	NonVoidInitializer parseNonVoidInitializer() { return null; }
-	Opcode parseOpcode() { return null; }
-	Operand parseOperand() { return null; }
-	Operands parseOperands() { return null; }
-	OrExpression parseOrExpression() { return null; }
-	OrOrExpression parseOrOrExpression() { return null; }
-	OutStatement parseOutStatement() { return null; }
-	Parameter parseParameter() { return null; }
-	ParameterAttribute parseParameterAttribute() { return null; }
-	Parameters parseParameters() { return null; }
-	PostIncDecExpression parsePostIncDecExpression() { return null; }
-	PowExpression parsePowExpression() { return null; }
-	PragmaDeclaration parsePragmaDeclaration() { return null; }
-	PragmaExpression parsePragmaExpression() { return null; }
-	PreIncDecExpression parsePreIncDecExpression() { return null; }
-	PrimaryExpression parsePrimaryExpression() { return null; }
-	ProtectionAttribute parseProtectionAttribute() { return null; }
-	Register parseRegister() { return null; }
-	RelExpression parseRelExpression() { return null; }
-	ReturnStatement parseReturnStatement() { return null; }
-	ScopeGuardStatement parseScopeGuardStatement() { return null; }
-	SharedStaticConstructor parseSharedStaticConstructor() { return null; }
-	SharedStaticDestructor parseSharedStaticDestructor() { return null; }
-	ShiftExpression parseShiftExpression() { return null; }
-	SingleImport parseSingleImport() { return null; }
-	Statement parseStatement() { return null; }
-	StatementNoCaseNoDefault parseStatementNoCaseNoDefault() { return null; }
-	StaticAssertDeclaration parseStaticAssertDeclaration() { return null; }
-	StaticAssertStatement parseStaticAssertStatement() { return null; }
-	StaticConstructor parseStaticConstructor() { return null; }
-	StaticDestructor parseStaticDestructor() { return null; }
-	StaticIfCondition parseStaticIfCondition() { return null; }
-	StorageClass parseStorageClass() { return null; }
-	StructBody parseStructBody() { return null; }
-	StructDeclaration parseStructDeclaration() { return null; }
-	StructInitializer parseStructInitializer() { return null; }
-	StructMemberInitializer parseStructMemberInitializer() { return null; }
-	StructMemberInitializers parseStructMemberInitializers() { return null; }
-	SwitchBody parseSwitchBody() { return null; }
-	SwitchStatement parseSwitchStatement() { return null; }
-	Symbol parseSymbol() { return null; }
-	SynchronizedStatement parseSynchronizedStatement() { return null; }
-	TemplateAliasParameter parseTemplateAliasParameter() { return null; }
-	TemplateArgument parseTemplateArgument() { return null; }
-	TemplateArgumentList parseTemplateArgumentList() { return null; }
-	TemplateArguments parseTemplateArguments() { return null; }
-	TemplateDeclaration parseTemplateDeclaration() { return null; }
-	TemplateInstance parseTemplateInstance() { return null; }
-	TemplateMixinStatement parseTemplateMixinStatement() { return null; }
-	TemplateParameter parseTemplateParameter() { return null; }
-	TemplateParameterList parseTemplateParameterList() { return null; }
-	TemplateParameters parseTemplateParameters() { return null; }
-	TemplateSingleArgument parseTemplateSingleArgument() { return null; }
-	TemplateThisParameter parseTemplateThisParameter() { return null; }
-	TemplateTupleParameter parseTemplateTupleParameter() { return null; }
-	TemplateTypeParameter parseTemplateTypeParameter() { return null; }
-	TemplateValueParameter parseTemplateValueParameter() { return null; }
-	TemplateValueParameterDefault parseTemplateValueParameterDefault() { return null; }
-	TernaryExpression parseTernaryExpression() { return null; }
-	ThrowStatement parseThrowStatement() { return null; }
-	TraitsArgument parseTraitsArgument() { return null; }
-	TraitsExpression parseTraitsExpression() { return null; }
-	TryStatement parseTryStatement() { return null; }
-	Type parseType() { return null; }
-	Type2 parseType2() { return null; }
-	Type3 parseType3() { return null; }
-	TypeConstructor parseTypeConstructor() { return null; }
-	TypeConstructors parseTypeConstructors() { return null; }
-	TypeSpecialization parseTypeSpecialization() { return null; }
-	TypeSuffix parseTypeSuffix() { return null; }
-	TypeidExpression parseTypeidExpression() { return null; }
-	TypeofExpression parseTypeofExpression() { return null; }
-	UnaryExpression parseUnaryExpression() { return null; }
-	UnionDeclaration parseUnionDeclaration() { return null; }
-	Unittest parseUnittest() { return null; }
-	VariableDeclaration parseVariableDeclaration() { return null; }
-	VersionCondition parseVersionCondition() { return null; }
-	VersionSpecification parseVersionSpecification() { return null; }
-	WhileStatement parseWhileStatement() { return null; }
-	WithStatement parseWithStatement() { return null; }
-	XorExpression parseXorExpression() { return null; }
+	NonEmptyStatementNoCaseNoDefault parseNonEmptyStatementNoCaseNoDefault()
+    {
+        auto node = new NonEmptyStatementNoCaseNoDefault;
+
+        return node;
+    }
+
+	NonVoidInitializer parseNonVoidInitializer()
+    {
+        auto node = new NonVoidInitializer;
+
+        return node;
+    }
+
+	Opcode parseOpcode()
+    {
+        auto node = new Opcode;
+
+        return node;
+    }
+
+	Operand parseOperand()
+    {
+        auto node = new Operand;
+
+        return node;
+    }
+
+	Operands parseOperands()
+    {
+        auto node = new Operands;
+
+        return node;
+    }
+
+	OrExpression parseOrExpression()
+    {
+        auto node = new OrExpression;
+
+        return node;
+    }
+
+	OrOrExpression parseOrOrExpression()
+    {
+        auto node = new OrOrExpression;
+
+        return node;
+    }
+
+	OutStatement parseOutStatement()
+    {
+        auto node = new OutStatement;
+
+        return node;
+    }
+
+	Parameter parseParameter()
+    {
+        auto node = new Parameter;
+
+        return node;
+    }
+
+	ParameterAttribute parseParameterAttribute()
+    {
+        auto node = new ParameterAttribute;
+
+        return node;
+    }
+
+	Parameters parseParameters()
+    {
+        auto node = new Parameters;
+
+        return node;
+    }
+
+	PostIncDecExpression parsePostIncDecExpression()
+    {
+        auto node = new PostIncDecExpression;
+
+        return node;
+    }
+
+	PowExpression parsePowExpression()
+    {
+        auto node = new PowExpression;
+
+        return node;
+    }
+
+	PragmaDeclaration parsePragmaDeclaration()
+    {
+        auto node = new PragmaDeclaration;
+
+        return node;
+    }
+
+	PragmaExpression parsePragmaExpression()
+    {
+        auto node = new PragmaExpression;
+
+        return node;
+    }
+
+	PreIncDecExpression parsePreIncDecExpression()
+    {
+        auto node = new PreIncDecExpression;
+
+        return node;
+    }
+
+	PrimaryExpression parsePrimaryExpression()
+    {
+        auto node = new PrimaryExpression;
+
+        return node;
+    }
+
+	ProtectionAttribute parseProtectionAttribute()
+    {
+        auto node = new ProtectionAttribute;
+
+        return node;
+    }
+
+	Register parseRegister()
+    {
+        auto node = new Register;
+
+        return node;
+    }
+
+	RelExpression parseRelExpression()
+    {
+        auto node = new RelExpression;
+
+        return node;
+    }
+
+	ReturnStatement parseReturnStatement()
+    {
+        auto node = new ReturnStatement;
+        expect(TokenType.return_);
+        if (tokens[index] != TokenType.semicolon)
+            node.expression = parseExpression();
+        expect(TokenType.semicolon);
+        return node;
+    }
+
+	ScopeGuardStatement parseScopeGuardStatement()
+    {
+        auto node = new ScopeGuardStatement;
+
+        return node;
+    }
+
+	SharedStaticConstructor parseSharedStaticConstructor()
+    {
+        auto node = new SharedStaticConstructor;
+
+        return node;
+    }
+
+	SharedStaticDestructor parseSharedStaticDestructor()
+    {
+        auto node = new SharedStaticDestructor;
+
+        return node;
+    }
+
+	ShiftExpression parseShiftExpression()
+    {
+        auto node = new ShiftExpression;
+
+        return node;
+    }
+
+	SingleImport parseSingleImport()
+    {
+        auto node = new SingleImport;
+
+        return node;
+    }
+
+	Statement parseStatement()
+    {
+        auto node = new Statement;
+        if (tokens[index] != TokenType.semicolon)
+            node.nonEmptyStatement = parseNonEmptyStatement();
+        else
+            expect(TokenType.semicolon);
+        return node;
+    }
+
+	StatementNoCaseNoDefault parseStatementNoCaseNoDefault()
+    {
+        auto node = new StatementNoCaseNoDefault;
+        if (tokens[index] != TokenType.semicolon)
+            node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
+        else
+            expect(TokenType.semicolon);
+        return node;
+    }
+
+	StaticAssertDeclaration parseStaticAssertDeclaration()
+    {
+        auto node = new StaticAssertDeclaration;
+        node.staticAssertStatement = parseStaticAssertStatement();
+        return node;
+    }
+
+	StaticAssertStatement parseStaticAssertStatement()
+    {
+        auto node = new StaticAssertStatement;
+        expect(TokenType.static_);
+        node.assertStatement = parseAssertStatement();
+        return node;
+    }
+
+	StaticConstructor parseStaticConstructor()
+    {
+        auto node = new StaticConstructor;
+        expect(TokenType.static_);
+        expect(TokenType.this_);
+        expect(TokenType.lParen);
+        expect(TokenType.rParen);
+        node.functionBody = parseFunctionBody();
+        return node;
+    }
+
+	StaticDestructor parseStaticDestructor()
+    {
+        auto node = new StaticDestructor;
+        expect(TokenType.static_);
+        expect(TokenType.tilde);
+        expect(TokenType.this_);
+        expect(TokenType.lParen);
+        expect(TokenType.rParen);
+        node.functionBody = parseFunctionBody();
+        return node;
+    }
+
+	StaticIfCondition parseStaticIfCondition()
+    {
+        auto node = new StaticIfCondition;
+        expect(TokenType.static_);
+        expect(TokenType.if_);
+        expect(TokenType.lParen);
+        node.assignExpression = parseAssignExpression();
+        expect(TokenType.rParen);
+        return node;
+    }
+
+	StorageClass parseStorageClass()
+    {
+        auto node = new StorageClass;
+
+        return node;
+    }
+
+	StructBody parseStructBody()
+    {
+        auto node = new StructBody;
+        expect(TokenType.lBrace);
+        while (tokens[index] != TokenType.rBrace && moreTokens())
+            node.declarations ~= parseDeclaration();
+        expect(TokenType.rBrace);
+        return node;
+    }
+
+	StructDeclaration parseStructDeclaration()
+    {
+        auto node = new StructDeclaration;
+        expect(TokenType.struct_);
+        node.identifier = *expect(TokenType.identifier);
+        if (tokens[index] == TokenType.lParen)
+        {
+            node.templateParameters = parseTemplateParameters();
+            if (tokens[index] == TokenType.if_)
+                node.constraint = parseConstraint();
+            node.structBody = parseStructBody();
+        }
+        else if (tokens[index] == TokenType.lBrace)
+        {
+            node.structBody = parseStructBody();
+        }
+        else if (tokens[index] != TokenType.semicolon)
+            error("Template Parameters, Struct Body, or Semicolon expected");
+        return node;
+    }
+
+	StructInitializer parseStructInitializer()
+    {
+        auto node = new StructInitializer;
+        expect(TokenType.lBrace);
+        node.structMemberInitializers = parseStructMemberInitializers();
+        expect(TokenType.rBrace);
+        return node;
+    }
+
+	StructMemberInitializer parseStructMemberInitializer()
+    {
+        auto node = new StructMemberInitializer;
+        if (startsWith(TokenType.identifier, TokenType.colon))
+        {
+            node.identifier = tokens[index++];
+            index++;
+        }
+        node.nonVoidInitializer = parseNonVoidInitializer();
+        return node;
+    }
+
+	StructMemberInitializers parseStructMemberInitializers()
+    {
+        auto node = new StructMemberInitializers;
+
+        return node;
+    }
+
+	SwitchBody parseSwitchBody()
+    {
+        auto node = new SwitchBody;
+        expect(TokenType.lBrace);
+        while (moreTokens() && tokens[index] != TokenType.rBrace)
+            node.statements ~= parseStatement();
+        expect(TokenType.rBrace);
+        return node;
+    }
+
+	SwitchStatement parseSwitchStatement()
+    {
+        auto node = new SwitchStatement;
+        expect(TokenType.switch_);
+        expect(TokenType.lParen);
+        node.expression = parseExpression();
+        expect(TokenType.rParen);
+        node.switchBody = parseSwitchBody();
+        return node;
+    }
+
+	Symbol parseSymbol()
+    {
+        auto node = new Symbol;
+        if (tokens[index] == TokenType.dot)
+        {
+            node.hasDot = true;
+            ++index;
+        }
+        node.identifierOrTemplateChain = parseIdentifierOrTemplateChain();
+        return node;
+    }
+
+	SynchronizedStatement parseSynchronizedStatement()
+    {
+        auto node = new SynchronizedStatement;
+        expect(TokenType.synchronized_);
+        if (tokens[index] == TokenType.lParen)
+        {
+            expect(TokenType.lParen);
+            node.expression = parseExpression();
+            expect(TokenType.rParen);
+        }
+        node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
+        return node;
+    }
+
+	TemplateAliasParameter parseTemplateAliasParameter()
+    {
+        auto node = new TemplateAliasParameter;
+
+        return node;
+    }
+
+	TemplateArgument parseTemplateArgument()
+    {
+        auto node = new TemplateArgument;
+
+        return node;
+    }
+
+	TemplateArgumentList parseTemplateArgumentList()
+    {
+        auto node = new TemplateArgumentList;
+
+        return node;
+    }
+
+	TemplateArguments parseTemplateArguments()
+    {
+        auto node = new TemplateArguments;
+
+        return node;
+    }
+
+	TemplateDeclaration parseTemplateDeclaration()
+    {
+        auto node = new TemplateDeclaration;
+
+        return node;
+    }
+
+	TemplateInstance parseTemplateInstance()
+    {
+        auto node = new TemplateInstance;
+
+        return node;
+    }
+
+	TemplateMixinStatement parseTemplateMixinStatement()
+    {
+        auto node = new TemplateMixinStatement;
+
+        return node;
+    }
+
+	TemplateParameter parseTemplateParameter()
+    {
+        auto node = new TemplateParameter;
+
+        return node;
+    }
+
+	TemplateParameterList parseTemplateParameterList()
+    {
+        auto node = new TemplateParameterList;
+
+        return node;
+    }
+
+	TemplateParameters parseTemplateParameters()
+    {
+        auto node = new TemplateParameters;
+
+        return node;
+    }
+
+	TemplateSingleArgument parseTemplateSingleArgument()
+    {
+        auto node = new TemplateSingleArgument;
+
+        return node;
+    }
+
+	TemplateThisParameter parseTemplateThisParameter()
+    {
+        auto node = new TemplateThisParameter;
+
+        return node;
+    }
+
+	TemplateTupleParameter parseTemplateTupleParameter()
+    {
+        auto node = new TemplateTupleParameter;
+
+        return node;
+    }
+
+	TemplateTypeParameter parseTemplateTypeParameter()
+    {
+        auto node = new TemplateTypeParameter;
+
+        return node;
+    }
+
+	TemplateValueParameter parseTemplateValueParameter()
+    {
+        auto node = new TemplateValueParameter;
+
+        return node;
+    }
+
+	TemplateValueParameterDefault parseTemplateValueParameterDefault()
+    {
+        auto node = new TemplateValueParameterDefault;
+
+        return node;
+    }
+
+	TernaryExpression parseTernaryExpression()
+    {
+        auto node = new TernaryExpression;
+        node.orOrExpression = parseOrOrExpression();
+        if (tokens[index] == TokenType.ternary)
+        {
+            ++index;
+            node.expression = parseExpression();
+            expect(TokenType.colon);
+            node.ternaryExpression = parseTernaryExpression();
+        }
+        return node;
+    }
+
+	ThrowStatement parseThrowStatement()
+    {
+        auto node = new ThrowStatement;
+        expect(TokenType.throw_);
+        node.expression = parseExpression();
+        expect(TokenType.semicolon);
+        return node;
+    }
+
+	TraitsArgument parseTraitsArgument()
+    {
+        auto node = new TraitsArgument;
+
+        return node;
+    }
+
+	TraitsExpression parseTraitsExpression()
+    {
+        auto node = new TraitsExpression;
+
+        return node;
+    }
+
+	TryStatement parseTryStatement()
+    {
+        auto node = new TryStatement;
+
+        return node;
+    }
+
+	Type parseType()
+    {
+        auto node = new Type;
+
+        return node;
+    }
+
+	Type2 parseType2()
+    {
+        auto node = new Type2;
+
+        return node;
+    }
+
+	Type3 parseType3()
+    {
+        auto node = new Type3;
+
+        return node;
+    }
+
+	TypeConstructor parseTypeConstructor()
+    {
+        auto node = new TypeConstructor;
+
+        return node;
+    }
+
+	TypeConstructors parseTypeConstructors()
+    {
+        auto node = new TypeConstructors;
+
+        return node;
+    }
+
+	TypeSpecialization parseTypeSpecialization()
+    {
+        auto node = new TypeSpecialization;
+
+        return node;
+    }
+
+	TypeSuffix parseTypeSuffix()
+    {
+        auto node = new TypeSuffix;
+
+        return node;
+    }
+
+	TypeidExpression parseTypeidExpression()
+    {
+        auto node = new TypeidExpression;
+
+        return node;
+    }
+
+	TypeofExpression parseTypeofExpression()
+    {
+        auto node = new TypeofExpression;
+        expect(TokenType.typeof_);
+        expect(TokenType.lParen);
+        if (tokens[index] == TokenType.return_)
+            node.return_ = tokens[index];
+        else
+            node.expression = parseExpression();
+        expect(TokenType.rParen);
+        return node;
+    }
+
+	UnaryExpression parseUnaryExpression()
+    {
+        auto node = new UnaryExpression;
+
+        return node;
+    }
+
+	UnionDeclaration parseUnionDeclaration()
+    {
+        auto node = new UnionDeclaration;
+
+        return node;
+    }
+
+	Unittest parseUnittest()
+    {
+        auto node = new Unittest;
+        expect(TokenType.unittest_);
+        node.blockStatement = parseBlockStatement();
+        return node;
+    }
+
+	VariableDeclaration parseVariableDeclaration()
+    {
+        auto node = new VariableDeclaration;
+
+        return node;
+    }
+
+	VersionCondition parseVersionCondition()
+    {
+        auto node = new VersionCondition;
+        expect(TokenType.version_);
+        expect(TokenType.lParen);
+        node.token = tokens[index];
+        expect(TokenType.rParen);
+        return node;
+    }
+
+	VersionSpecification parseVersionSpecification()
+    {
+        auto node = new VersionSpecification;
+        expect(TokenType.version_);
+        expect(TokenType.assign);
+        node.token = tokens[index];
+        expect(TokenType.semicolon);
+        return node;
+    }
+
+	WhileStatement parseWhileStatement()
+    {
+        auto node = new WhileStatement;
+
+        return node;
+    }
+
+	WithStatement parseWithStatement()
+    {
+        auto node = new WithStatement;
+        expect(TokenType.with_);
+        expect(TokenType.lParen);
+        // magic here
+        expect(TokenType.rParen);
+        parseNonEmptyStatementNoCaseNoDefault();
+        return node;
+    }
+
+	XorExpression parseXorExpression()
+    {
+        auto node = new XorExpression;
+
+        return node;
+    }
 
 	///////////////////////////////////////////////////////////////
 
@@ -470,7 +1676,7 @@ struct Parser
 		switch (tokens[index].type)
 		{
 			case TokenType.identifier:
-				c.identifier = tokens[index++].value;
+				c.identifier = tokens[index++];
 				goto case;
 			case TokenType.semicolon:
 				return c;
@@ -552,7 +1758,7 @@ struct Parser
         return peek() && peek().type == t;
     }
 
-    bool startsWith(TokenType types...)
+    bool startsWith(TokenType[] types...)
     {
         for (size_t i = 0; i != types.length; ++i)
         {