projects/dil: trunk/src/dil/parser/Parser.d comparison

comparison trunk/src/dil/parser/Parser.d @ 679:ff6971637f88

Renamed Token member type to kind.

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Fri, 18 Jan 2008 23:40:12 +0100
parents	118971211c4c
children	6b3e397229c5

comparison

equal deleted inserted replaced

-:cedfc67faabf
+:ff6971637f88
 Declarations start()
 {
 init();
 auto begin = token;
 auto decls = new Declarations;
-if (token.type == T.Module)
+if (token.kind == T.Module)
 decls ~= parseModuleDeclaration();
 decls.addOptChildren(parseDeclarationDefinitions());
 set(decls, begin);
 return decls;
 }
 {
 Token* next = token;
 do
 lexer.peek(next);
 while (next.isWhitespace) // Skip whitespace
-return next.type;
+return next.kind;
 }
 TOK peekAfter(ref Token* next)
 {
 assert(next !is null);
 do
 lexer.peek(next);
 while (next.isWhitespace) // Skip whitespace
-return next.type;
+return next.kind;
 }
 /// Skips the current token if its type matches tok and returns true.
 bool skipped()(TOK tok) // Templatized, so it's inlined.
 {
-return token.type == tok ? (nT(), true) : false;
+return token.kind == tok ? (nT(), true) : false;
 }
 /++++++++++++++++++++++++++++++
 + Declaration parsing methods +
 ++++++++++++++++++++++++++++++/
 Declaration parseModuleDeclaration()
 {
-assert(token.type == T.Module);
+assert(token.kind == T.Module);
 auto begin = token;
 ModuleFQN moduleFQN;
 do
 {
 nT();
 moduleFQN ~= requireIdentifier(MSG.ExpectedModuleIdentifier);
-} while (token.type == T.Dot)
+} while (token.kind == T.Dot)
 require(T.Semicolon);
 return set(new ModuleDeclaration(moduleFQN), begin);
 }
 /++
 DeclDefs
 +/
 Declaration[] parseDeclarationDefinitions()
 {
 Declaration[] decls;
-while (token.type != T.EOF)
+while (token.kind != T.EOF)
 decls ~= parseDeclarationDefinition();
 return decls;
 }
 /++
 // Parse body.
 auto begin = token;
 auto decls = new Declarations;
 require(T.LBrace);
-while (token.type != T.RBrace && token.type != T.EOF)
+while (token.kind != T.RBrace && token.kind != T.EOF)
 decls ~= parseDeclarationDefinition();
 require(T.RBrace);
 set(decls, begin);
 // Restore original values.
 { assert(isNodeSet(decl)); }
 body
 {
 auto begin = token;
 Declaration decl;
-switch (token.type)
+switch (token.kind)
 {
 case T.Align,
 T.Pragma,
 // Protection attributes
 T.Export,
 case_Declaration:
 return parseVariableOrFunction(this.storageClass, this.protection, this.linkageType);
 default:
 if (token.isIntegralType)
 goto case_Declaration;
-else if (token.type == T.Module)
+else if (token.kind == T.Module)
 {
 decl = parseModuleDeclaration();
 error(begin, MSG.ModuleDeclarationNotFirst);
 return decl;
 }
 decl = new IllegalDeclaration();
 // Skip to next valid token.
 do
 nT();
 while (!token.isDeclDefStart &&
-token.type != T.RBrace &&
+token.kind != T.RBrace &&
-token.type != T.EOF)
+token.kind != T.EOF)
 auto text = Token.textSpan(begin, this.prevToken);
 error(begin, MSG.IllegalDeclaration, text);
 }
 decl.setProtection(this.protection);
 decl.setStorageClass(this.storageClass);
 DeclDef
 +/
 Declaration parseDeclarationsBlock(bool noColon = false)
 {
 Declaration d;
-switch (token.type)
+switch (token.kind)
 {
 case T.LBrace:
 auto begin = token;
 nT();
 auto decls = new Declarations;
-while (token.type != T.RBrace && token.type != T.EOF)
+while (token.kind != T.RBrace && token.kind != T.EOF)
 decls ~= parseDeclarationDefinition();
 require(T.RBrace);
 d = set(decls, begin);
 break;
 case T.Colon:
 if (noColon == true)
 goto default;
 nT();
 auto begin = token;
 auto decls = new Declarations;
-while (token.type != T.RBrace && token.type != T.EOF)
+while (token.kind != T.RBrace && token.kind != T.EOF)
 decls ~= parseDeclarationDefinition();
 d = set(decls, begin);
 break;
 default:
 d = parseDeclarationDefinition();
 Type type;
 Identifier* ident;
 // Check for AutoDeclaration: StorageClasses Identifier =
 if (testAutoDeclaration &&
-token.type == T.Identifier &&
+token.kind == T.Identifier &&
 peekNext() == T.Assign)
 {
 ident = token.ident;
 nT();
 }
 else
 {
 type = parseType(); // VariableType or ReturnType
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 {
 // C-style function pointers make the grammar ambiguous.
 // We have to treat them specially at function scope.
 // Example:
 //   void foo() {
 }
 else if (peekNext() == T.LParen)
 { // Type FunctionName ( ParameterList ) FunctionBody
 ident = requireIdentifier(MSG.ExpectedFunctionName);
 ident || nT(); // Skip non-identifier token.
-assert(token.type == T.LParen);
+assert(token.kind == T.LParen);
 // It's a function declaration
 TemplateParameters tparams;
 if (tokenAfterParenIs(T.LParen))
 {
 // ( TemplateParameterList ) ( ParameterList )
 }
 auto params = parseParameterList();
 version(D2)
 {
-switch (token.type)
+switch (token.kind)
 {
 case T.Const:
 stc |= StorageClass.Const;
 nT();
 break;
 // It's a variable declaration.
 Identifier*[] idents = [ident];
 Expression[] values;
 goto LenterLoop; // We've already parsed an identifier. Jump to if statement and check for initializer.
-while (token.type == T.Comma)
+while (token.kind == T.Comma)
 {
 nT();
 idents ~= requireIdentifier(MSG.ExpectedVariableName);
 LenterLoop:
 if (skipped(T.Assign))
 return set(d, begin);
 }
 Expression parseInitializer()
 {
-if (token.type == T.Void)
+if (token.kind == T.Void)
 {
 auto begin = token;
 auto next = peekNext();
 if (next == T.Comma || next == T.Semicolon)
 {
 Expression parseNonVoidInitializer()
 {
 auto begin = token;
 Expression init;
-switch (token.type)
+switch (token.kind)
 {
 case T.LBracket:
 // ArrayInitializer:
 //         [ ]
 //         [ ArrayMemberInitializations ]
 Expression[] keys;
 Expression[] values;
 nT();
-while (token.type != T.RBracket)
+while (token.kind != T.RBracket)
 {
 auto e = parseNonVoidInitializer();
 if (skipped(T.Colon))
 {
 keys ~= e;
 {
 keys ~= null;
 values ~= e;
 }
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT();
 }
 require(T.RBracket);
 init = new ArrayInitializer(keys, values);
 {
 Identifier*[] idents;
 Expression[] values;
 nT();
-while (token.type != T.RBrace)
+while (token.kind != T.RBrace)
 {
-if (token.type == T.Identifier &&
+if (token.kind == T.Identifier &&
 // Peek for colon to see if this is a member identifier.
 peekNext() == T.Colon)
 {
 idents ~= token.ident;
 nT(), nT(); // Skip Identifier :
 idents ~= null;
 // NonVoidInitializer
 values ~= parseNonVoidInitializer();
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT();
 }
 require(T.RBrace);
 return new StructInitializer(idents, values);
 if (success)
 {
 init = si;
 break;
 }
-assert(token.type == T.LBrace);
+assert(token.kind == T.LBrace);
 //goto default;
 default:
 init = parseAssignExpression();
 }
 set(init, begin);
 {
 auto begin = token;
 auto func = new FunctionBody;
 while (1)
 {
-switch (token.type)
+switch (token.kind)
 {
 case T.LBrace:
 func.funcBody = parseStatements();
 break;
 case T.Semicolon:
 }
 LinkageType parseLinkageType()
 {
 LinkageType linkageType;
-if (token.type != T.LParen)
+if (token.kind != T.LParen)
 return linkageType;
 nT(); // Skip (
-if (token.type == T.RParen)
+if (token.kind == T.RParen)
 {
 nT();
 error(MID.MissingLinkageType);
 return linkageType;
 }
 // Nested function.
 Declaration parse()
 {
 Declaration decl;
 auto begin = token;
-switch (token.type)
+switch (token.kind)
 {
 case T.Extern:
 if (peekNext() != T.LParen)
 {
 stc_tmp = StorageClass.Extern;
 return parse();
 }
 uint parseAlignAttribute()
 {
-assert(token.type == T.Align);
+assert(token.kind == T.Align);
 nT(); // Skip align keyword.
 uint size = DEFAULT_ALIGN_SIZE; // Global default.
 if (skipped(T.LParen))
 {
-if (token.type == T.Int32)
+if (token.kind == T.Int32)
 (size = token.int_), nT();
 else
 expected(T.Int32);
 require(T.RParen);
 }
 Declaration parseAttributeSpecifier()
 {
 Declaration decl;
-switch (token.type)
+switch (token.kind)
 {
 case T.Align:
 uint alignSize = parseAlignAttribute();
 auto saved = this.alignSize; // Save.
 this.alignSize = alignSize; // Set.
 decl = new PragmaDeclaration(ident, args, parseDeclarationsBlock());
 break;
 default:
 // Protection attributes
 Protection prot;
-switch (token.type)
+switch (token.kind)
 {
 case T.Private:
 prot = Protection.Private; break;
 case T.Package:
 prot = Protection.Package; break;
 return decl;
 }
 Declaration parseImportDeclaration()
 {
-assert(token.type == T.Import || token.type == T.Static);
+assert(token.kind == T.Import || token.kind == T.Static);
 bool isStatic = skipped(T.Static);
-assert(token.type == T.Import);
+assert(token.kind == T.Import);
 nT(); // Skip import keyword.
 ModuleFQN[] moduleFQNs;
 Identifier*[] moduleAliases;
 Identifier*[] bindNames;
 // Identifier(.Identifier)*
 while (1)
 {
 moduleFQN ~= requireIdentifier(MSG.ExpectedModuleIdentifier);
-if (token.type != T.Dot)
+if (token.kind != T.Dot)
 break;
 nT();
 }
 // Push identifiers.
 moduleFQNs ~= moduleFQN;
 moduleAliases ~= moduleAlias;
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT();
 }
-if (token.type == T.Colon)
+if (token.kind == T.Colon)
 {
 // BindAlias = BindName(, BindAlias = BindName)*;
 // BindName(, BindName)*;
 do
 {
 nT(); // Skip =
 }
 // Push identifiers.
 bindNames ~= requireIdentifier(MSG.ExpectedImportName);
 bindAliases ~= bindAlias;
-} while (token.type == T.Comma)
+} while (token.kind == T.Comma)
 }
 require(T.Semicolon);
 return new ImportDeclaration(moduleFQNs, moduleAliases, bindNames, bindAliases, isStatic);
 }
 Declaration parseEnumDeclaration()
 {
-assert(token.type == T.Enum);
+assert(token.kind == T.Enum);
 nT(); // Skip enum keyword.
 Identifier* enumName;
 Type baseType;
 EnumMember[] members;
 if (enumName && skipped(T.Semicolon))
 {}
 else if (skipped(T.LBrace))
 {
 hasBody = true;
-while (token.type != T.RBrace)
+while (token.kind != T.RBrace)
 {
 auto begin = token;
 auto name = requireIdentifier(MSG.ExpectedEnumMember);
 Expression value;
 else
 value = null;
 members ~= set(new EnumMember(name, value), begin);
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT(); // Skip ,
 }
 require(T.RBrace);
 }
 return new EnumDeclaration(enumName, baseType, members, hasBody);
 }
 Declaration parseClassDeclaration()
 {
-assert(token.type == T.Class);
+assert(token.kind == T.Class);
 nT(); // Skip class keyword.
 Identifier* className;
 TemplateParameters tparams;
 BaseClassType[] bases;
 Declarations decls;
 className = requireIdentifier(MSG.ExpectedClassName);
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 tparams = parseTemplateParameterList();
-if (token.type == T.Colon)
+if (token.kind == T.Colon)
 bases = parseBaseClasses();
 if (bases.length == 0 && skipped(T.Semicolon))
 {}
-else if (token.type == T.LBrace)
+else if (token.kind == T.LBrace)
 decls = parseDeclarationDefinitionsBody();
 else
 error(token, MSG.ExpectedClassBody, token.srcText);
 return new ClassDeclaration(className, tparams, bases, decls);
 BaseClassType[] parseBaseClasses(bool colonLeadsOff = true)
 {
 if (colonLeadsOff)
 {
-assert(token.type == T.Colon);
+assert(token.kind == T.Colon);
 nT(); // Skip colon
 }
 BaseClassType[] bases;
 do
 {
 Protection prot = Protection.Public;
-switch (token.type)
+switch (token.kind)
 {
 case T.Identifier, T.Dot, T.Typeof: goto LparseBasicType;
 case T.Private:   prot = Protection.Private;   break;
 case T.Protected: prot = Protection.Protected; break;
 case T.Package:   prot = Protection.Package;   break;
 return bases;
 }
 Declaration parseInterfaceDeclaration()
 {
-assert(token.type == T.Interface);
+assert(token.kind == T.Interface);
 nT(); // Skip interface keyword.
 Identifier* name;
 TemplateParameters tparams;
 BaseClassType[] bases;
 Declarations decls;
 name = requireIdentifier(MSG.ExpectedInterfaceName);
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 tparams = parseTemplateParameterList();
-if (token.type == T.Colon)
+if (token.kind == T.Colon)
 bases = parseBaseClasses();
 if (bases.length == 0 && skipped(T.Semicolon))
 {}
-else if (token.type == T.LBrace)
+else if (token.kind == T.LBrace)
 decls = parseDeclarationDefinitionsBody();
 else
 error(token, MSG.ExpectedInterfaceBody, token.srcText);
 return new InterfaceDeclaration(name, tparams, bases, decls);
 }
 Declaration parseStructOrUnionDeclaration()
 {
-assert(token.type == T.Struct || token.type == T.Union);
+assert(token.kind == T.Struct || token.kind == T.Union);
-TOK tok = token.type;
+TOK tok = token.kind;
 nT(); // Skip struct or union keyword.
 Identifier* name;
 TemplateParameters tparams;
 Declarations decls;
 name = optionalIdentifier();
-if (name && token.type == T.LParen)
+if (name && token.kind == T.LParen)
 tparams = parseTemplateParameterList();
 if (name && skipped(T.Semicolon))
 {}
-else if (token.type == T.LBrace)
+else if (token.kind == T.LBrace)
 decls = parseDeclarationDefinitionsBody();
 else
 error(token, tok == T.Struct ?
 MSG.ExpectedStructBody :
 MSG.ExpectedUnionBody, token.srcText);
 return new UnionDeclaration(name, tparams, decls);
 }
 Declaration parseConstructorDeclaration()
 {
-assert(token.type == T.This);
+assert(token.kind == T.This);
 nT(); // Skip 'this' keyword.
 auto parameters = parseParameterList();
 auto funcBody = parseFunctionBody();
 return new ConstructorDeclaration(parameters, funcBody);
 }
 Declaration parseDestructorDeclaration()
 {
-assert(token.type == T.Tilde);
+assert(token.kind == T.Tilde);
 nT(); // Skip ~
 require(T.This);
 require(T.LParen);
 require(T.RParen);
 auto funcBody = parseFunctionBody();
 return new DestructorDeclaration(funcBody);
 }
 Declaration parseStaticConstructorDeclaration()
 {
-assert(token.type == T.Static);
+assert(token.kind == T.Static);
 nT(); // Skip static keyword.
 nT(); // Skip 'this' keyword.
 require(T.LParen);
 require(T.RParen);
 auto funcBody = parseFunctionBody();
 return new StaticConstructorDeclaration(funcBody);
 }
 Declaration parseStaticDestructorDeclaration()
 {
-assert(token.type == T.Static);
+assert(token.kind == T.Static);
 nT(); // Skip static keyword.
 nT(); // Skip ~
 require(T.This);
 require(T.LParen);
 require(T.RParen);
 return new StaticDestructorDeclaration(funcBody);
 }
 Declaration parseInvariantDeclaration()
 {
-assert(token.type == T.Invariant);
+assert(token.kind == T.Invariant);
 nT(); // Skip invariant keyword.
 // Optional () for getting ready porting to D 2.0
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 requireNext(T.RParen);
 auto funcBody = parseFunctionBody();
 return new InvariantDeclaration(funcBody);
 }
 Declaration parseUnittestDeclaration()
 {
-assert(token.type == T.Unittest);
+assert(token.kind == T.Unittest);
 nT(); // Skip unittest keyword.
 auto funcBody = parseFunctionBody();
 return new UnittestDeclaration(funcBody);
 }
 return null;
 }
 Declaration parseDebugDeclaration()
 {
-assert(token.type == T.Debug);
+assert(token.kind == T.Debug);
 nT(); // Skip debug keyword.
 Token* spec;
 Token* cond;
 Declaration decls, elseDecls;
 return new DebugDeclaration(spec, cond, decls, elseDecls);
 }
 Declaration parseVersionDeclaration()
 {
-assert(token.type == T.Version);
+assert(token.kind == T.Version);
 nT(); // Skip version keyword.
 Token* spec;
 Token* cond;
 Declaration decls, elseDecls;
 return new VersionDeclaration(spec, cond, decls, elseDecls);
 }
 Declaration parseStaticIfDeclaration()
 {
-assert(token.type == T.Static);
+assert(token.kind == T.Static);
 nT(); // Skip static keyword.
 nT(); // Skip if keyword.
 Expression condition;
 Declaration ifDecls, elseDecls;
 return new StaticIfDeclaration(condition, ifDecls, elseDecls);
 }
 Declaration parseStaticAssertDeclaration()
 {
-assert(token.type == T.Static);
+assert(token.kind == T.Static);
 nT(); // Skip static keyword.
 nT(); // Skip assert keyword.
 Expression condition, message;
 require(T.LParen);
 condition = parseAssignExpression();
 return new StaticAssertDeclaration(condition, message);
 }
 Declaration parseTemplateDeclaration()
 {
-assert(token.type == T.Template);
+assert(token.kind == T.Template);
 nT(); // Skip template keyword.
 auto templateName = requireIdentifier(MSG.ExpectedTemplateName);
 auto templateParams = parseTemplateParameterList();
 auto decls = parseDeclarationDefinitionsBody();
 return new TemplateDeclaration(templateName, templateParams, decls);
 }
 Declaration parseNewDeclaration()
 {
-assert(token.type == T.New);
+assert(token.kind == T.New);
 nT(); // Skip new keyword.
 auto parameters = parseParameterList();
 auto funcBody = parseFunctionBody();
 return new NewDeclaration(parameters, funcBody);
 }
 Declaration parseDeleteDeclaration()
 {
-assert(token.type == T.Delete);
+assert(token.kind == T.Delete);
 nT(); // Skip delete keyword.
 auto parameters = parseParameterList();
 auto funcBody = parseFunctionBody();
 return new DeleteDeclaration(parameters, funcBody);
 }
 Type parseTypeofType()
 {
-assert(token.type == T.Typeof);
+assert(token.kind == T.Typeof);
 auto begin = token;
 Type type;
 requireNext(T.LParen);
-switch (token.type)
+switch (token.kind)
 {
 version(D2)
 {
 case T.Return:
 nT();
 mixin TemplateIdentifier !( TemplateArguments ) ;
 mixin TemplateIdentifier !( TemplateArguments ) MixinIdentifier ;
 */
 Class parseMixin(Class)()
 {
-assert(token.type == T.Mixin);
+assert(token.kind == T.Mixin);
 nT(); // Skip mixin keyword.
 static if (is(Class == MixinDeclaration))
 {
 if (skipped(T.LParen))
 Statements parseStatements()
 {
 auto begin = token;
 require(T.LBrace);
 auto statements = new Statements();
-while (token.type != T.RBrace && token.type != T.EOF)
+while (token.kind != T.RBrace && token.kind != T.EOF)
 statements ~= parseStatement();
 require(T.RBrace);
 return set(statements, begin);
 }
 {
 d = parseVariableOrFunction();
 goto LreturnDeclarationStatement;
 }
-switch (token.type)
+switch (token.kind)
 {
 case T.Align:
 uint size = parseAlignAttribute();
 // Restrict align attribute to structs in parsing phase.
 StructDeclaration structDecl;
-if (token.type == T.Struct)
+if (token.kind == T.Struct)
 {
 auto begin2 = token;
 structDecl = parseStructOrUnionDeclaration().to!(StructDeclaration);
 structDecl.setAlignSize(size);
 set(structDecl, begin2);
 break;
 default:
 if (token.isSpecialToken)
 goto case_parseExpressionStatement;
-if (token.type != T.Dollar)
+if (token.kind != T.Dollar)
 // Assert that this isn't a valid expression.
 assert(delegate bool(){
 bool success;
 auto expression = try_(&parseExpression, success);
 return success;
 s = new IllegalStatement();
 // Skip to next valid token.
 do
 nT();
 while (!token.isStatementStart &&
-token.type != T.RBrace &&
+token.kind != T.RBrace &&
-token.type != T.EOF)
+token.kind != T.EOF)
 auto text = Token.textSpan(begin, this.prevToken);
 error(begin, MSG.IllegalStatement, text);
 }
 assert(s !is null);
 set(s, begin);
 auto begin = token;
 Statement s;
 if (skipped(T.LBrace))
 {
 auto ss = new Statements();
-while (token.type != T.RBrace && token.type != T.EOF)
+while (token.kind != T.RBrace && token.kind != T.EOF)
 ss ~= parseStatement();
 require(T.RBrace);
 s = set(ss, begin);
 }
-else if (token.type == T.Semicolon)
+else if (token.kind == T.Semicolon)
 {
 error(token, MSG.ExpectedNonEmptyStatement);
 nT();
 s = set(new EmptyStatement(), begin);
 }
 // Nested function.
 Declaration parse()
 {
 auto begin = token;
 Declaration d;
-switch (token.type)
+switch (token.kind)
 {
 case T.Extern:
 if (peekNext() != T.LParen)
 {
 stc_tmp = StorageClass.Extern;
 return new DeclarationStatement(parse());
 }
 Statement parseIfStatement()
 {
-assert(token.type == T.If);
+assert(token.kind == T.If);
 nT();
 Statement variable;
 Expression condition;
 Statement ifBody, elseBody;
 return new IfStatement(variable, condition, ifBody, elseBody);
 }
 Statement parseWhileStatement()
 {
-assert(token.type == T.While);
+assert(token.kind == T.While);
 nT();
 require(T.LParen);
 auto condition = parseExpression();
 require(T.RParen);
 return new WhileStatement(condition, parseScopeStatement());
 }
 Statement parseDoWhileStatement()
 {
-assert(token.type == T.Do);
+assert(token.kind == T.Do);
 nT();
 auto doBody = parseScopeStatement();
 require(T.While);
 require(T.LParen);
 auto condition = parseExpression();
 return new DoWhileStatement(condition, doBody);
 }
 Statement parseForStatement()
 {
-assert(token.type == T.For);
+assert(token.kind == T.For);
 nT();
 require(T.LParen);
 Statement init, forBody;
 Expression condition, increment;
-if (token.type != T.Semicolon)
+if (token.kind != T.Semicolon)
 init = parseNoScopeStatement();
 else
 nT(); // Skip ;
-if (token.type != T.Semicolon)
+if (token.kind != T.Semicolon)
 condition = parseExpression();
 require(T.Semicolon);
-if (token.type != T.RParen)
+if (token.kind != T.RParen)
 increment = parseExpression();
 require(T.RParen);
 forBody = parseScopeStatement();
 return new ForStatement(init, condition, increment, forBody);
 }
 Statement parseForeachStatement()
 {
-assert(token.type == T.Foreach || token.type == T.Foreach_reverse);
+assert(token.kind == T.Foreach || token.kind == T.Foreach_reverse);
-TOK tok = token.type;
+TOK tok = token.kind;
 nT();
 auto params = new Parameters;
 Expression e; // Aggregate or LwrExpression
 auto paramBegin = token;
 StorageClass stc;
 Type type;
 Identifier* ident;
-switch (token.type)
+switch (token.kind)
 {
 case T.Ref, T.Inout:
 stc = StorageClass.Ref;
 nT();
 // fall through
 type = parseDeclarator(ident);
 }
 params ~= set(new Parameter(stc, type, ident, null), paramBegin);
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT();
 }
 require(T.Semicolon);
 e = parseExpression();
 return new ForeachStatement(tok, params, e, forBody);
 }
 Statement parseSwitchStatement()
 {
-assert(token.type == T.Switch);
+assert(token.kind == T.Switch);
 nT();
 require(T.LParen);
 auto condition = parseExpression();
 require(T.RParen);
 auto switchBody = parseScopeStatement();
 Statement parseCaseOrDefaultBody()
 {
 // This function is similar to parseNoScopeStatement()
 auto begin = token;
 auto s = new Statements();
-while (token.type != T.Case &&
+while (token.kind != T.Case &&
-token.type != T.Default &&
+token.kind != T.Default &&
-token.type != T.RBrace &&
+token.kind != T.RBrace &&
-token.type != T.EOF)
+token.kind != T.EOF)
 s ~= parseStatement();
 return set(new ScopeStatement(s), begin);
 }
 Statement parseCaseStatement()
 {
-assert(token.type == T.Case);
+assert(token.kind == T.Case);
 nT();
 auto values = parseExpressionList();
 require(T.Colon);
 auto caseBody = parseCaseOrDefaultBody();
 return new CaseStatement(values, caseBody);
 }
 Statement parseDefaultStatement()
 {
-assert(token.type == T.Default);
+assert(token.kind == T.Default);
 nT();
 require(T.Colon);
 auto defaultBody = parseCaseOrDefaultBody();
 return new DefaultStatement(defaultBody);
 }
 Statement parseContinueStatement()
 {
-assert(token.type == T.Continue);
+assert(token.kind == T.Continue);
 nT();
 auto ident = optionalIdentifier();
 require(T.Semicolon);
 return new ContinueStatement(ident);
 }
 Statement parseBreakStatement()
 {
-assert(token.type == T.Break);
+assert(token.kind == T.Break);
 nT();
 auto ident = optionalIdentifier();
 require(T.Semicolon);
 return new BreakStatement(ident);
 }
 Statement parseReturnStatement()
 {
-assert(token.type == T.Return);
+assert(token.kind == T.Return);
 nT();
 Expression expr;
-if (token.type != T.Semicolon)
+if (token.kind != T.Semicolon)
 expr = parseExpression();
 require(T.Semicolon);
 return new ReturnStatement(expr);
 }
 Statement parseGotoStatement()
 {
-assert(token.type == T.Goto);
+assert(token.kind == T.Goto);
 nT();
 Identifier* ident;
 Expression caseExpr;
-switch (token.type)
+switch (token.kind)
 {
 case T.Case:
 nT();
-if (token.type == T.Semicolon)
+if (token.kind == T.Semicolon)
 break;
 caseExpr = parseExpression();
 break;
 case T.Default:
 nT();
 return new GotoStatement(ident, caseExpr);
 }
 Statement parseWithStatement()
 {
-assert(token.type == T.With);
+assert(token.kind == T.With);
 nT();
 require(T.LParen);
 auto expr = parseExpression();
 require(T.RParen);
 return new WithStatement(expr, parseScopeStatement());
 }
 Statement parseSynchronizedStatement()
 {
-assert(token.type == T.Synchronized);
+assert(token.kind == T.Synchronized);
 nT();
 Expression expr;
 if (skipped(T.LParen))
 {
 expr = parseExpression();
 return new SynchronizedStatement(expr, parseScopeStatement());
 }
 Statement parseTryStatement()
 {
-assert(token.type == T.Try);
+assert(token.kind == T.Try);
 auto begin = token;
 nT();
 auto tryBody = parseScopeStatement();
 CatchBody[] catchBodies;
 if (skipped(T.Finally))
 finBody = set(new FinallyBody(parseNoScopeStatement()), prevToken);
 if (catchBodies.length == 0 && finBody is null)
-assert(begin.type == T.Try), error(begin, MSG.MissingCatchOrFinally);
+assert(begin.kind == T.Try), error(begin, MSG.MissingCatchOrFinally);
 return new TryStatement(tryBody, catchBodies, finBody);
 }
 Statement parseThrowStatement()
 {
-assert(token.type == T.Throw);
+assert(token.kind == T.Throw);
 nT();
 auto expr = parseExpression();
 require(T.Semicolon);
 return new ThrowStatement(expr);
 }
 Statement parseScopeGuardStatement()
 {
-assert(token.type == T.Scope);
+assert(token.kind == T.Scope);
 nT();
-assert(token.type == T.LParen);
+assert(token.kind == T.LParen);
 nT();
 auto condition = requireIdentifier(MSG.ExpectedScopeIdentifier);
 if (condition)
 switch (condition.identID)
 {
 default:
 error(this.prevToken, MSG.InvalidScopeIdentifier, this.prevToken.srcText);
 }
 require(T.RParen);
 Statement scopeBody;
-if (token.type == T.LBrace)
+if (token.kind == T.LBrace)
 scopeBody = parseScopeStatement();
 else
 scopeBody = parseNoScopeStatement();
 return new ScopeGuardStatement(condition, scopeBody);
 }
 Statement parseVolatileStatement()
 {
-assert(token.type == T.Volatile);
+assert(token.kind == T.Volatile);
 nT();
 Statement volatileBody;
-if (token.type == T.Semicolon)
+if (token.kind == T.Semicolon)
 nT();
-else if (token.type == T.LBrace)
+else if (token.kind == T.LBrace)
 volatileBody = parseScopeStatement();
 else
 volatileBody = parseStatement();
 return new VolatileStatement(volatileBody);
 }
 Statement parsePragmaStatement()
 {
-assert(token.type == T.Pragma);
+assert(token.kind == T.Pragma);
 nT();
 Identifier* ident;
 Expression[] args;
 Statement pragmaBody;
 return new PragmaStatement(ident, args, pragmaBody);
 }
 Statement parseStaticIfStatement()
 {
-assert(token.type == T.Static);
+assert(token.kind == T.Static);
 nT();
-assert(token.type == T.If);
+assert(token.kind == T.If);
 nT();
 Expression condition;
 Statement ifBody, elseBody;
 require(T.LParen);
 return new StaticIfStatement(condition, ifBody, elseBody);
 }
 Statement parseStaticAssertStatement()
 {
-assert(token.type == T.Static);
+assert(token.kind == T.Static);
 nT();
-assert(token.type == T.Assert);
+assert(token.kind == T.Assert);
 nT();
 Expression condition, message;
 require(T.LParen);
 condition = parseAssignExpression(); // Condition.
 if (skipped(T.Comma))
 return new StaticAssertStatement(condition, message);
 }
 Statement parseDebugStatement()
 {
-assert(token.type == T.Debug);
+assert(token.kind == T.Debug);
 nT(); // Skip debug keyword.
 Token* cond;
 Statement debugBody, elseBody;
 return new DebugStatement(cond, debugBody, elseBody);
 }
 Statement parseVersionStatement()
 {
-assert(token.type == T.Version);
+assert(token.kind == T.Version);
 nT(); // Skip version keyword.
 Token* cond;
 Statement versionBody, elseBody;
 + Assembler parsing methods  +
 +++++++++++++++++++++++++++++/
 Statement parseAsmStatement()
 {
-assert(token.type == T.Asm);
+assert(token.kind == T.Asm);
 nT(); // Skip asm keyword.
 require(T.LBrace);
 auto ss = new Statements;
-while (token.type != T.RBrace && token.type != T.EOF)
+while (token.kind != T.RBrace && token.kind != T.EOF)
 ss ~= parseAsmInstruction();
 require(T.RBrace);
 return new AsmStatement(ss);
 }
 Statement parseAsmInstruction()
 {
 auto begin = token;
 Statement s;
 Identifier* ident;
-switch (token.type)
+switch (token.kind)
 {
 // Keywords that are valid opcodes.
 case T.In, T.Int, T.Out:
 ident = token.ident;
 nT();
 // Opcode ;
 // Opcode Operands ;
 // Opcode
 //     Identifier
 Expression[] es;
-if (token.type != T.Semicolon)
+if (token.kind != T.Semicolon)
 do
 es ~= parseAsmExpression();
 while (skipped(T.Comma))
 require(T.Semicolon);
 s = new AsmInstruction(ident, es);
 break;
 case T.Align:
 // align Integer;
 nT();
 int number = -1;
-if (token.type == T.Int32)
+if (token.kind == T.Int32)
 (number = token.int_), nT();
 else
 error(token, MSG.ExpectedIntegerAfterAlign, token.srcText);
 require(T.Semicolon);
 s = new AsmAlignStatement(number);
 s = new IllegalAsmInstruction();
 // Skip to next valid token.
 do
 nT();
 while (!token.isAsmInstructionStart &&
-token.type != T.RBrace &&
+token.kind != T.RBrace &&
-token.type != T.EOF)
+token.kind != T.EOF)
 auto text = Token.textSpan(begin, this.prevToken);
 error(begin, MSG.IllegalAsmInstruction, text);
 }
 set(s, begin);
 return s;
 Expression parseAsmOrOrExpression()
 {
 alias parseAsmAndAndExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.OrLogical)
+while (token.kind == T.OrLogical)
 {
 auto tok = token;
 nT();
 e = new OrOrExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseAsmAndAndExpression()
 {
 alias parseAsmOrExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.AndLogical)
+while (token.kind == T.AndLogical)
 {
 auto tok = token;
 nT();
 e = new AndAndExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseAsmOrExpression()
 {
 alias parseAsmXorExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.OrBinary)
+while (token.kind == T.OrBinary)
 {
 auto tok = token;
 nT();
 e = new OrExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseAsmXorExpression()
 {
 alias parseAsmAndExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.Xor)
+while (token.kind == T.Xor)
 {
 auto tok = token;
 nT();
 e = new XorExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseAsmAndExpression()
 {
 alias parseAsmCmpExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.AndBinary)
+while (token.kind == T.AndBinary)
 {
 auto tok = token;
 nT();
 e = new AndExpression(e, parseNext(), tok);
 set(e, begin);
 alias parseAsmShiftExpression parseNext;
 auto begin = token;
 auto e = parseNext();
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.Equal, T.NotEqual:
 nT();
 e = new EqualExpression(e, parseNext(), operator);
 break;
 auto begin = token;
 auto e = parseNext();
 while (1)
 {
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.LShift:  nT(); e = new LShiftExpression(e, parseNext(), operator); break;
 case T.RShift:  nT(); e = new RShiftExpression(e, parseNext(), operator); break;
 case T.URShift: nT(); e = new URShiftExpression(e, parseNext(), operator); break;
 default:
 auto begin = token;
 auto e = parseNext();
 while (1)
 {
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.Plus:  nT(); e = new PlusExpression(e, parseNext(), operator); break;
 case T.Minus: nT(); e = new MinusExpression(e, parseNext(), operator); break;
 // Not allowed in asm
 //case T.Tilde: nT(); e = new CatExpression(e, parseNext(), operator); break;
 auto begin = token;
 auto e = parseNext();
 while (1)
 {
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.Mul: nT(); e = new MulExpression(e, parseNext(), operator); break;
 case T.Div: nT(); e = new DivExpression(e, parseNext(), operator); break;
 case T.Mod: nT(); e = new ModExpression(e, parseNext(), operator); break;
 default:
 Expression parseAsmUnaryExpression()
 {
 auto begin = token;
 Expression e;
-switch (token.type)
+switch (token.kind)
 {
 case T.Byte,  T.Short,  T.Int,
 T.Float, T.Double, T.Real:
 goto LAsmTypePrefix;
 case T.Identifier:
 {
 case ID.near, ID.far,/* "byte",  "short",  "int",*/
 ID.word, ID.dword, ID.qword/*, "float", "double", "real"*/:
 LAsmTypePrefix:
 nT();
-if (token.type == T.Identifier && token.ident is Ident.ptr)
+if (token.kind == T.Identifier && token.ident is Ident.ptr)
 nT();
 else
 error(MID.ExpectedButFound, "ptr", token.srcText);
 e = new AsmTypeExpression(parseAsmExpression());
 break;
 Expression parseAsmPrimaryExpression()
 {
 auto begin = token;
 Expression e;
-switch (token.type)
+switch (token.kind)
 {
 case T.Int32, T.Int64, T.Uint32, T.Uint64:
 e = new IntExpression(token);
 nT();
 break;
 nT();
 // (1) - (7)
 int number = -1;
 if (skipped(T.LParen))
 {
-if (token.type == T.Int32)
+if (token.kind == T.Int32)
 (number = token.int_), nT();
 else
 expected(T.Int32);
 require(T.RParen);
 }
 // TODO: is the colon-number part optional?
 int number = -1;
 if (skipped(T.Colon))
 {
 // :0, :4, :8
-if (token.type == T.Int32)
+if (token.kind == T.Int32)
 (number = token.int_), nT();
 if (number != 0 && number != 4 && number != 8)
 error(MID.ExpectedButFound, "0, 4 or 8", token.srcText);
 }
 e = new AsmRegisterExpression(register, number);
 Expression parseExpression()
 {
 alias parseAssignExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.Comma)
+while (token.kind == T.Comma)
 {
 auto comma = token;
 nT();
 e = new CommaExpression(e, parseNext(), comma);
 set(e, begin);
 Expression parseAssignExpression()
 {
 alias parseAssignExpression parseNext;
 auto begin = token;
 auto e = parseCondExpression();
-switch (token.type)
+switch (token.kind)
 {
 case T.Assign:
 nT(); e = new AssignExpression(e, parseNext()); break;
 case T.LShiftAssign:
 nT(); e = new LShiftAssignExpression(e, parseNext()); break;
 Expression parseCondExpression()
 {
 auto begin = token;
 auto e = parseOrOrExpression();
-if (token.type == T.Question)
+if (token.kind == T.Question)
 {
 auto tok = token;
 nT();
 auto iftrue = parseExpression();
 require(T.Colon);
 Expression parseOrOrExpression()
 {
 alias parseAndAndExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.OrLogical)
+while (token.kind == T.OrLogical)
 {
 auto tok = token;
 nT();
 e = new OrOrExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseAndAndExpression()
 {
 alias parseOrExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.AndLogical)
+while (token.kind == T.AndLogical)
 {
 auto tok = token;
 nT();
 e = new AndAndExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseOrExpression()
 {
 alias parseXorExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.OrBinary)
+while (token.kind == T.OrBinary)
 {
 auto tok = token;
 nT();
 e = new OrExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseXorExpression()
 {
 alias parseAndExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.Xor)
+while (token.kind == T.Xor)
 {
 auto tok = token;
 nT();
 e = new XorExpression(e, parseNext(), tok);
 set(e, begin);
 Expression parseAndExpression()
 {
 alias parseCmpExpression parseNext;
 auto begin = token;
 auto e = parseNext();
-while (token.type == T.AndBinary)
+while (token.kind == T.AndBinary)
 {
 auto tok = token;
 nT();
 e = new AndExpression(e, parseNext(), tok);
 set(e, begin);
 alias parseShiftExpression parseNext;
 auto begin = token;
 auto e = parseShiftExpression();
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.Equal, T.NotEqual:
 nT();
 e = new EqualExpression(e, parseNext(), operator);
 break;
 auto begin = token;
 auto e = parseNext();
 while (1)
 {
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.LShift:  nT(); e = new LShiftExpression(e, parseNext(), operator); break;
 case T.RShift:  nT(); e = new RShiftExpression(e, parseNext(), operator); break;
 case T.URShift: nT(); e = new URShiftExpression(e, parseNext(), operator); break;
 default:
 auto begin = token;
 auto e = parseNext();
 while (1)
 {
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.Plus:  nT(); e = new PlusExpression(e, parseNext(), operator); break;
 case T.Minus: nT(); e = new MinusExpression(e, parseNext(), operator); break;
 case T.Tilde: nT(); e = new CatExpression(e, parseNext(), operator); break;
 default:
 auto begin = token;
 auto e = parseNext();
 while (1)
 {
 auto operator = token;
-switch (operator.type)
+switch (operator.kind)
 {
 case T.Mul: nT(); e = new MulExpression(e, parseNext(), operator); break;
 case T.Div: nT(); e = new DivExpression(e, parseNext(), operator); break;
 case T.Mod: nT(); e = new ModExpression(e, parseNext(), operator); break;
 default:
 {
 e = new DotExpression(e, parseNewOrIdentifierExpression());
 set(e, begin);
 }
-switch (token.type)
+switch (token.kind)
 {
 case T.PlusPlus:
 e = new PostIncrExpression(e);
 break;
 case T.MinusMinus:
 goto Lset;
 case T.LBracket:
 // parse Slice- and IndexExpression
 nT();
 // [] is a SliceExpression
-if (token.type == T.RBracket)
+if (token.kind == T.RBracket)
 {
 e = new SliceExpression(e, null, null);
 break;
 }
 Expression parseUnaryExpression()
 {
 auto begin = token;
 Expression e;
-switch (token.type)
+switch (token.kind)
 {
 case T.AndBinary:
 nT();
 e = new AddressExpression(parseUnaryExpression());
 break;
 e = new DeleteExpression(parseUnaryExpression());
 break;
 case T.Cast:
 requireNext(T.LParen);
 Type type;
-switch (token.type)
+switch (token.kind)
 {
 version(D2)
 {
 auto begin2 = token;
 case T.Const:
 {
 auto begin = token;
 auto ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 Expression e;
 // Peek for '(' to avoid matching: id !is id
-if (token.type == T.Not && peekNext() == T.LParen)
+if (token.kind == T.Not && peekNext() == T.LParen)
 { // Identifier !( TemplateArguments )
 nT(); // Skip !.
 auto tparams = parseTemplateArguments();
 e = new TemplateInstanceExpression(ident, tparams);
 }
 return set(e, begin);
 }
 Expression parseNewOrIdentifierExpression()
 {
-return token.type == T.New ? parseNewExpression() :  parseIdentifierExpression();
+return token.kind == T.New ? parseNewExpression() :  parseIdentifierExpression();
 }
 Expression parsePrimaryExpression()
 {
 auto begin = token;
 Expression e;
-switch (token.type)
+switch (token.kind)
 {
 case T.Identifier:
 e = parseIdentifierExpression();
 return e;
 case T.Typeof:
 break;
 case T.String:
 char[] str = token.str;
 char postfix = token.pf;
 nT();
-while (token.type == T.String)
+while (token.kind == T.String)
 {
 if (postfix == '\0')
 postfix = token.pf;
 else if (token.pf && token.pf != postfix)
 error(token, MSG.StringPostfixMismatch);
 nT();
 if (!skipped(T.RBracket))
 {
 e = parseAssignExpression();
-if (token.type == T.Colon)
+if (token.kind == T.Colon)
 goto LparseAssocArray;
 if (skipped(T.Comma))
 values = [e] ~ parseExpressionList();
 require(T.RBracket);
 }
 {
 keys ~= parseAssignExpression();
 require(T.Colon);
 LenterLoop:
 values ~= parseAssignExpression();
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT();
 }
 require(T.RBracket);
 e = new AArrayLiteralExpression(keys, values);
 case T.Function, T.Delegate:
 // FunctionLiteral := (function|delegate) Type? '(' ArgumentList ')' '{' Statements '}'
 nT(); // Skip function|delegate token.
 Type returnType;
 Parameters parameters;
-if (token.type != T.LBrace)
+if (token.kind != T.LBrace)
 {
-if (token.type != T.LParen) // Optional return type
+if (token.kind != T.LParen) // Optional return type
 returnType = parseType();
 parameters = parseParameterList();
 }
 auto funcBody = parseFunctionBody();
 e = new FunctionLiteralExpression(returnType, parameters, funcBody);
 Identifier* ident; // optional Identifier
 Token* opTok, specTok;
 type = parseDeclarator(ident, true);
-switch (token.type)
+switch (token.kind)
 {
 case T.Colon, T.Equal:
 opTok = token;
 nT();
-switch (token.type)
+switch (token.kind)
 {
 case T.Typedef,
 T.Struct,
 T.Union,
 T.Class,
 TemplateParameters tparams;
 version(D2)
 {
 // is ( Type Identifier : TypeSpecialization , TemplateParameterList )
 // is ( Type Identifier == TypeSpecialization , TemplateParameterList )
-if (ident && specType && token.type == T.Comma)
+if (ident && specType && token.kind == T.Comma)
 tparams = parseTemplateParameterList2();
 }
 require(T.RParen);
 e = new IsExpression(type, ident, opTok, specTok, specType, tparams);
 break;
 case T.Traits:
 nT();
 require(T.LParen);
 auto id = requireIdentifier(MSG.ExpectedAnIdentifier);
 TemplateArguments args;
-if (token.type == T.Comma)
+if (token.kind == T.Comma)
 args = parseTemplateArguments2();
 else
 require(T.RParen);
 e = new TraitsExpression(id, args);
 break;
 }
 default:
 if (token.isIntegralType)
 { // IntegralType . Identifier
-auto type = new IntegralType(token.type);
+auto type = new IntegralType(token.kind);
 nT();
 set(type, begin);
 require(T.Dot);
 auto ident = requireIdentifier(MSG.ExpectedIdAfterTypeDot);
 e = new TypeDotIdExpression(type, ident);
 }
 Expression parseNewExpression(/*Expression e*/)
 {
 auto begin = token;
-assert(token.type == T.New);
+assert(token.kind == T.New);
 nT(); // Skip new keyword.
 Expression[] newArguments;
 Expression[] ctorArguments;
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 newArguments = parseArguments();
 // NewAnonClassExpression:
 //         new (ArgumentList)opt class (ArgumentList)opt SuperClassopt InterfaceClassesopt ClassBody
 if (skipped(T.Class))
 {
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 ctorArguments = parseArguments();
-BaseClassType[] bases = token.type != T.LBrace ? parseBaseClasses(false) : null ;
+BaseClassType[] bases = token.kind != T.LBrace ? parseBaseClasses(false) : null ;
 auto decls = parseDeclarationDefinitionsBody();
 return set(new NewAnonClassExpression(/*e, */newArguments, bases, ctorArguments, decls), begin);
 }
 //         NewArguments Type [ AssignExpression ]
 //         NewArguments Type ( ArgumentList )
 //         NewArguments Type
 auto type = parseType();
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 ctorArguments = parseArguments();
 return set(new NewExpression(/*e, */newArguments, type, ctorArguments), begin);
 }
 {
 auto begin = token;
 Type type;
 if (skipped(T.Dot))
 type = set(new ModuleScopeType(parseIdentifierType()), begin);
-else if (token.type == T.Typeof)
+else if (token.kind == T.Typeof)
 {
 type = parseTypeofType();
-if (token.type != T.Dot)
+if (token.kind != T.Dot)
 return type;
 }
 else
 type = parseIdentifierType();
 auto begin = token;
 Type t;
 if (token.isIntegralType)
 {
-t = new IntegralType(token.type);
+t = new IntegralType(token.kind);
 nT();
 }
 else
-switch (token.type)
+switch (token.kind)
 {
 case T.Identifier, T.Typeof, T.Dot:
 t = parseQualifiedType();
 return t;
 version(D2)
 {
 typeof(token) begin;
 while (1)
 {
 begin = token;
-switch (token.type)
+switch (token.kind)
 {
 case T.Mul:
 t = new PointerType(t);
 nT();
 break;
 case T.LBracket:
 t = parseArrayType(t);
 continue;
 case T.Function, T.Delegate:
-TOK tok = token.type;
+TOK tok = token.kind;
 nT();
 auto parameters = parseParameterList();
 if (tok == T.Function)
 t = new FunctionType(t, parameters);
 else
 }
 bool tokenAfterParenIs(TOK tok)
 {
 // We count nested parentheses tokens because template types may appear inside parameter lists; e.g. (int x, Foo!(int) y).
-assert(token.type == T.LParen);
+assert(token.kind == T.LParen);
 Token* next = token;
 uint level = 1;
 Loop:
 while (1)
 {
 lexer.peek(next);
-switch (next.type)
+switch (next.kind)
 {
 case T.RParen:
 if (--level == 0)
 { // Last, closing parentheses found.
 do
 case T.EOF:
 break Loop;
 default:
 }
 }
-return next.type == tok;
+return next.kind == tok;
 }
 /// Parse the C-style array types after the declarator.
 Type parseDeclaratorSuffix(Type lhsType)
 {
 //   <- <-              ->  -.
 //       ^------------------´
 // Resulting chain: [][32]*[3]int
 Type parseNext() // Nested function required to accomplish this.
 {
-if (token.type != T.LBracket)
+if (token.kind != T.LBracket)
 return lhsType; // Break recursion; return Type on the left hand side of the Identifier.
 auto begin = token;
 Type t;
 nT();
 return parseNext();
 }
 Type parseArrayType(Type t)
 {
-assert(token.type == T.LBracket);
+assert(token.kind == T.LBracket);
 auto begin = token;
 nT();
 if (skipped(T.RBracket))
 t = new ArrayType(t);
 else
 return t;
 }
 Type parseCFunctionPointerType(Type type, ref Identifier* ident, bool optionalParamList)
 {
-assert(token.type == T.LParen);
+assert(token.kind == T.LParen);
 assert(type !is null);
 auto begin = token;
 nT(); // Skip (
 type = parseBasicType2(type);
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 {
 // Can be nested.
 type = parseCFunctionPointerType(type, ident, true);
 }
-else if (token.type == T.Identifier)
+else if (token.kind == T.Identifier)
 {
 // The identifier of the function pointer and the declaration.
 ident = token.ident;
 nT();
 type = parseDeclaratorSuffix(type);
 }
 require(T.RParen);
 Parameters params;
 if (optionalParamList)
-params = token.type == T.LParen ? parseParameterList() : null;
+params = token.kind == T.LParen ? parseParameterList() : null;
 else
 params = parseParameterList();
 type = new CFuncPointerType(type, params);
 return set(type, begin);
 Type parseDeclarator(ref Identifier* ident, bool identOptional = false)
 {
 auto t = parseType();
-if (token.type == T.LParen)
+if (token.kind == T.LParen)
 t = parseCFunctionPointerType(t, ident, true);
-else if (token.type == T.Identifier)
+else if (token.kind == T.Identifier)
 {
 ident = token.ident;
 nT();
 t = parseDeclaratorSuffix(t);
 }
 ( )
 ( ExpressionList )
 +/
 Expression[] parseArguments()
 {
-assert(token.type == T.LParen);
+assert(token.kind == T.LParen);
 nT();
 Expression[] args;
-if (token.type != TOK.RParen)
+if (token.kind != TOK.RParen)
 args = parseExpressionList();
 require(TOK.RParen);
 return args;
 }
 pushParameter(); // type, ident and defValue will be null.
 break Loop;
 }
 Lstc_loop:
-switch (token.type)
+switch (token.kind)
 {
 version(D2)
 {
 case T.Invariant: // D2.0
 if (peekNext() == T.LParen)
 break Loop;
 }
 pushParameter();
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break Loop;
 nT();
 }
 }
 require(T.RParen);
 TemplateArguments parseTemplateArguments()
 {
 TemplateArguments targs;
 require(T.LParen);
-if (token.type != T.RParen)
+if (token.kind != T.RParen)
 targs = parseTemplateArguments_();
 require(T.RParen);
 return targs;
 }
 version(D2)
 {
 TemplateArguments parseTemplateArguments2()
 {
-assert(token.type == T.Comma);
+assert(token.kind == T.Comma);
 nT();
 TemplateArguments targs;
-if (token.type != T.RParen)
+if (token.kind != T.RParen)
 targs = parseTemplateArguments_();
 else
 error(token, MSG.ExpectedTypeOrExpression);
 require(T.RParen);
 return targs;
 while (1)
 {
 Type parseType_()
 {
 auto type = parseType();
-if (token.type == T.Comma || token.type == T.RParen)
+if (token.kind == T.Comma || token.kind == T.RParen)
 return type;
 ++errorCount; // Cause try_() to fail.
 return null;
 }
 bool success;
 targs ~= typeArgument;
 else
 // TemplateArgument:
 //         AssignExpression
 targs ~= parseAssignExpression();
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break; // Exit loop.
 nT();
 }
 set(targs, begin);
 return targs;
 TemplateParameters parseTemplateParameterList()
 {
 TemplateParameters tparams;
 require(T.LParen);
-if (token.type != T.RParen)
+if (token.kind != T.RParen)
 tparams = parseTemplateParameterList_();
 require(T.RParen);
 return tparams;
 }
 version(D2)
 {
 TemplateParameters parseTemplateParameterList2()
 {
-assert(token.type == T.Comma);
+assert(token.kind == T.Comma);
 nT();
 TemplateParameters tparams;
-if (token.type != T.RParen)
+if (token.kind != T.RParen)
 tparams = parseTemplateParameterList_();
 else
 error(token, MSG.ExpectedTemplateParameters);
 return tparams;
 }
 // = DefaultType
 if (skipped(T.Assign))
 defType = parseType();
 }
-switch (token.type)
+switch (token.kind)
 {
 case T.Alias:
 // TemplateAliasParameter:
 //         alias Identifier
 nT(); // Skip alias keyword.
 case T.Ellipses:
 // TemplateTupleParameter:
 //         Identifier ...
 nT(); // Skip Identifier.
 nT(); // Skip Ellipses.
-if (token.type == T.Comma)
+if (token.kind == T.Comma)
 error(MID.TemplateTupleParameter);
 tp = new TemplateTupleParameter(ident);
 break;
 case T.Comma, T.RParen, T.Colon, T.Assign:
 // TemplateTypeParameter:
 }
 // Push template parameter.
 tparams ~= set(tp, paramBegin);
-if (token.type != T.Comma)
+if (token.kind != T.Comma)
 break;
 nT();
 }
 set(tparams, begin);
 return tparams;
 }
 void expected(TOK tok)
 {
-if (token.type != tok)
+if (token.kind != tok)
 error(MID.ExpectedButFound, Token.toString(tok), token.srcText);
 }
 void require(TOK tok)
 {
-if (token.type == tok)
+if (token.kind == tok)
 nT();
 else
 error(MID.ExpectedButFound, Token.toString(tok), token.srcText);
 }
 }
 Identifier* optionalIdentifier()
 {
 Identifier* id;
-if (token.type == T.Identifier)
+if (token.kind == T.Identifier)
 (id = token.ident), nT();
 return id;
 }
 Identifier* requireIdentifier()
 {
 Identifier* id;
-if (token.type == T.Identifier)
+if (token.kind == T.Identifier)
 (id = token.ident), nT();
 else
 error(MID.ExpectedButFound, "Identifier", token.srcText);
 return id;
 }
 errorMsg = an error that has no message ID yet.
 +/
 Identifier* requireIdentifier(char[] errorMsg)
 {
 Identifier* id;
-if (token.type == T.Identifier)
+if (token.kind == T.Identifier)
 (id = token.ident), nT();
 else
 error(token, errorMsg, token.srcText);
 return id;
 }
 Identifier* requireIdentifier(MID mid)
 {
 Identifier* id;
-if (token.type == T.Identifier)
+if (token.kind == T.Identifier)
 (id = token.ident), nT();
 else
 error(mid, token.srcText);
 return id;
 }
 Token* requireId()
 {
-if (token.type == T.Identifier)
+if (token.kind == T.Identifier)
 {
 auto id = token;
 nT();
 return id;
 }
 }
 Token* requireIdToken(char[] errorMsg)
 {
 Token* idtok;
-if (token.type == T.Identifier)
+if (token.kind == T.Identifier)
 (idtok = token), nT();
 else
 error(token, errorMsg, token.srcText);
 return idtok;
 }

Mercurial > projects > dil

comparison trunk/src/dil/parser/Parser.d @ 679:ff6971637f88