microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-15 19:55:08 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Initial work on making all node construction in the parser consistent.

Browse Source
This commit is contained in:
Cyrus Najmabadi 2014-11-21 19:50:08 -08:00
parent 9d079b40bd
commit f559effe5d
1 changed files with 52 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
src/compiler/parser.ts
View File

@ -3140,14 +3140,14 @@ module ts {
Debug.fail("Should not have attempted to parse class member declaration.");
}
function parseClassDeclaration(pos: number, flags: NodeFlags): ClassDeclaration {
var node = <ClassDeclaration>createNode(SyntaxKind.ClassDeclaration, pos);
node.flags = flags;
function parseClassDeclaration(fullStart: number, modifiers: ModifiersArray): ClassDeclaration {
var node = <ClassDeclaration>createNode(SyntaxKind.ClassDeclaration, fullStart);
setModifiers(node, modifiers);
parseExpected(SyntaxKind.ClassKeyword);
node.name = parseIdentifier();
node.typeParameters = parseTypeParameters();
// TODO(jfreeman): Parse arbitrary sequence of heritage clauses and error for order and duplicates
// TODO(jfreeman): Parse arbitrary sequence of heritage clauses and error for order and duplicates
node.baseType = parseOptional(SyntaxKind.ExtendsKeyword) ? parseTypeReference() : undefined;
if (parseOptional(SyntaxKind.ImplementsKeyword)) {
node.implementedTypes = parseDelimitedList(ParsingContext.BaseTypeReferences, parseTypeReference);
@ -3162,9 +3162,9 @@ module ts {
return finishNode(node);
}
function parseInterfaceDeclaration(pos: number, flags: NodeFlags): InterfaceDeclaration {
var node = <InterfaceDeclaration>createNode(SyntaxKind.InterfaceDeclaration, pos);
node.flags = flags;
function parseInterfaceDeclaration(fullStart: number, modifiers: ModifiersArray): InterfaceDeclaration {
var node = <InterfaceDeclaration>createNode(SyntaxKind.InterfaceDeclaration, fullStart);
setModifiers(node, modifiers);
parseExpected(SyntaxKind.InterfaceKeyword);
node.name = parseIdentifier();
node.typeParameters = parseTypeParameters();
@ -3176,9 +3176,9 @@ module ts {
return finishNode(node);
}
function parseTypeAliasDeclaration(pos: number, flags: NodeFlags): TypeAliasDeclaration {
var node = <TypeAliasDeclaration>createNode(SyntaxKind.TypeAliasDeclaration, pos);
node.flags = flags;
function parseTypeAliasDeclaration(fullStart: number, modifiers: ModifiersArray): TypeAliasDeclaration {
var node = <TypeAliasDeclaration>createNode(SyntaxKind.TypeAliasDeclaration, fullStart);
setModifiers(node, modifiers);
parseExpected(SyntaxKind.TypeKeyword);
node.name = parseIdentifier();
parseExpected(SyntaxKind.EqualsToken);
@ -3187,23 +3187,21 @@ module ts {
return finishNode(node);
}
function parseAndCheckEnumDeclaration(pos: number, flags: NodeFlags): EnumDeclaration {
var enumIsConst = flags & NodeFlags.Const;
// In an ambient declaration, the grammar only allows integer literals as initializers.
// In a non-ambient declaration, the grammar allows uninitialized members only in a
// ConstantEnumMemberSection, which starts at the beginning of an enum declaration
// or any time an integer literal initializer is encountered.
function parseEnumMember(): EnumMember {
var node = <EnumMember>createNode(SyntaxKind.EnumMember, scanner.getStartPos());
node.name = parsePropertyName();
node.initializer = parseInitializer(/*inParameter*/ false);
return finishNode(node);
}
// In an ambient declaration, the grammar only allows integer literals as initializers.
// In a non-ambient declaration, the grammar allows uninitialized members only in a
// ConstantEnumMemberSection, which starts at the beginning of an enum declaration
// or any time an integer literal initializer is encountered.
function parseEnumMember(): EnumMember {
var node = <EnumMember>createNode(SyntaxKind.EnumMember);
node.name = parsePropertyName();
node.initializer = parseInitializer(/*inParameter*/ false);
return finishNode(node);
}
var node = <EnumDeclaration>createNode(SyntaxKind.EnumDeclaration, pos);
function parseAndCheckEnumDeclaration(fullStart: number, flags: NodeFlags): EnumDeclaration {
var node = <EnumDeclaration>createNode(SyntaxKind.EnumDeclaration, fullStart);
node.flags = flags;
if (enumIsConst) {
if (flags & NodeFlags.Const) {
parseExpected(SyntaxKind.ConstKeyword);
}
parseExpected(SyntaxKind.EnumKeyword);
@ -3219,7 +3217,7 @@ module ts {
}
function parseModuleBody(): Block {
var node = <Block>createNode(SyntaxKind.ModuleBlock);
var node = <Block>createNode(SyntaxKind.ModuleBlock, scanner.getStartPos());
if (parseExpected(SyntaxKind.OpenBraceToken)) {
node.statements = parseList(ParsingContext.ModuleElements, /*checkForStrictMode*/ false, parseModuleElement);
parseExpected(SyntaxKind.CloseBraceToken);
@ -3230,35 +3228,34 @@ module ts {
return finishNode(node);
}
function parseInternalModuleTail(pos: number, flags: NodeFlags): ModuleDeclaration {
var node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, pos);
function parseInternalModuleTail(fullStart: number, flags: NodeFlags): ModuleDeclaration {
var node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
node.flags = flags;
node.name = parseIdentifier();
if (parseOptional(SyntaxKind.DotToken)) {
node.body = parseInternalModuleTail(getNodePos(), NodeFlags.Export);
}
else {
node.body = parseModuleBody();
}
node.body = parseOptional(SyntaxKind.DotToken)
? parseInternalModuleTail(getNodePos(), NodeFlags.Export)
: parseModuleBody();
return finishNode(node);
}
function parseAmbientExternalModuleDeclaration(pos: number, flags: NodeFlags): ModuleDeclaration {
var node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, pos);
function parseAmbientExternalModuleDeclaration(fullStart: number, flags: NodeFlags): ModuleDeclaration {
var node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
node.flags = flags;
node.name = parseStringLiteral();
node.body = parseModuleBody();
return finishNode(node);
}
function parseModuleDeclaration(pos: number, flags: NodeFlags): ModuleDeclaration {
function parseModuleDeclaration(fullStart: number, flags: NodeFlags): ModuleDeclaration {
parseExpected(SyntaxKind.ModuleKeyword);
return token === SyntaxKind.StringLiteral ? parseAmbientExternalModuleDeclaration(pos, flags) : parseInternalModuleTail(pos, flags);
return token === SyntaxKind.StringLiteral
? parseAmbientExternalModuleDeclaration(fullStart, flags)
: parseInternalModuleTail(fullStart, flags);
}
function parseImportDeclaration(pos: number, flags: NodeFlags): ImportDeclaration {
var node = <ImportDeclaration>createNode(SyntaxKind.ImportDeclaration, pos);
node.flags = flags;
function parseImportDeclaration(fullStart: number, modifiers: ModifiersArray): ImportDeclaration {
var node = <ImportDeclaration>createNode(SyntaxKind.ImportDeclaration, fullStart);
setModifiers(node, modifiers);
parseExpected(SyntaxKind.ImportKeyword);
node.name = parseIdentifier();
parseExpected(SyntaxKind.EqualsToken);
@ -3274,10 +3271,9 @@ module ts {
return finishNode(node);
}
function parseExportAssignmentTail(pos: number, modifiers: ModifiersArray): ExportAssignment {
var node = <ExportAssignment>createNode(SyntaxKind.ExportAssignment, pos);
function parseExportAssignmentTail(fullStart: number, modifiers: ModifiersArray): ExportAssignment {
var node = <ExportAssignment>createNode(SyntaxKind.ExportAssignment, fullStart);
setModifiers(node, modifiers);
node.exportName = parseIdentifier();
parseSemicolon();
return finishNode(node);
@ -3314,12 +3310,12 @@ module ts {
}
function parseDeclaration(modifierContext: ModifierContext): Statement {
var pos = getNodePos();
var fullStart = getNodePos();
var modifiers = parseModifiers(modifierContext);
if (token === SyntaxKind.ExportKeyword) {
nextToken();
if (parseOptional(SyntaxKind.EqualsToken)) {
return parseExportAssignmentTail(pos, modifiers);
return parseExportAssignmentTail(fullStart, modifiers);
}
}
@ -3328,37 +3324,37 @@ module ts {
switch (token) {
case SyntaxKind.VarKeyword:
case SyntaxKind.LetKeyword:
result = parseVariableStatement(pos, flags);
result = parseVariableStatement(fullStart, flags);
break;
case SyntaxKind.ConstKeyword:
var isConstEnum = lookAhead(() => nextToken() === SyntaxKind.EnumKeyword);
if (isConstEnum) {
result = parseAndCheckEnumDeclaration(pos, flags | NodeFlags.Const);
result = parseAndCheckEnumDeclaration(fullStart, flags | NodeFlags.Const);
}
else {
result = parseVariableStatement(pos, flags);
result = parseVariableStatement(fullStart, flags);
}
break;
case SyntaxKind.FunctionKeyword:
result = parseFunctionDeclaration(pos, flags);
result = parseFunctionDeclaration(fullStart, flags);
break;
case SyntaxKind.ClassKeyword:
result = parseClassDeclaration(pos, flags);
result = parseClassDeclaration(fullStart, modifiers);
break;
case SyntaxKind.InterfaceKeyword:
result = parseInterfaceDeclaration(pos, flags);
result = parseInterfaceDeclaration(fullStart, modifiers);
break;
case SyntaxKind.TypeKeyword:
result = parseTypeAliasDeclaration(pos, flags);
result = parseTypeAliasDeclaration(fullStart, modifiers);
break;
case SyntaxKind.EnumKeyword:
result = parseAndCheckEnumDeclaration(pos, flags);
result = parseAndCheckEnumDeclaration(fullStart, flags);
break;
case SyntaxKind.ModuleKeyword:
result = parseModuleDeclaration(pos, flags);
result = parseModuleDeclaration(fullStart, flags);
break;
case SyntaxKind.ImportKeyword:
result = parseImportDeclaration(pos, flags);
result = parseImportDeclaration(fullStart, modifiers);
break;
default:
error(Diagnostics.Declaration_expected);