From f559effe5d626d7228b111f7e68a6a77a7e62571 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 21 Nov 2014 19:50:08 -0800 Subject: [PATCH 1/5] Initial work on making all node construction in the parser consistent. --- src/compiler/parser.ts | 108 ++++++++++++++++++++--------------------- 1 file changed, 52 insertions(+), 56 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 117de20dd5f..ea025bd2a62 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -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 = createNode(SyntaxKind.ClassDeclaration, pos); - node.flags = flags; + function parseClassDeclaration(fullStart: number, modifiers: ModifiersArray): ClassDeclaration { + var node = 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 = createNode(SyntaxKind.InterfaceDeclaration, pos); - node.flags = flags; + function parseInterfaceDeclaration(fullStart: number, modifiers: ModifiersArray): InterfaceDeclaration { + var node = 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 = createNode(SyntaxKind.TypeAliasDeclaration, pos); - node.flags = flags; + function parseTypeAliasDeclaration(fullStart: number, modifiers: ModifiersArray): TypeAliasDeclaration { + var node = 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 = 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 = createNode(SyntaxKind.EnumMember); - node.name = parsePropertyName(); - node.initializer = parseInitializer(/*inParameter*/ false); - return finishNode(node); - } - - var node = createNode(SyntaxKind.EnumDeclaration, pos); + function parseAndCheckEnumDeclaration(fullStart: number, flags: NodeFlags): EnumDeclaration { + var node = 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 = createNode(SyntaxKind.ModuleBlock); + var node = 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 = createNode(SyntaxKind.ModuleDeclaration, pos); + function parseInternalModuleTail(fullStart: number, flags: NodeFlags): ModuleDeclaration { + var node = 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 = createNode(SyntaxKind.ModuleDeclaration, pos); + function parseAmbientExternalModuleDeclaration(fullStart: number, flags: NodeFlags): ModuleDeclaration { + var node = 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 = createNode(SyntaxKind.ImportDeclaration, pos); - node.flags = flags; + function parseImportDeclaration(fullStart: number, modifiers: ModifiersArray): ImportDeclaration { + var node = 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 = createNode(SyntaxKind.ExportAssignment, pos); + function parseExportAssignmentTail(fullStart: number, modifiers: ModifiersArray): ExportAssignment { + var node = 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); From a36e6addd12f84da9eadeef2a04df80f338b0518 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 21 Nov 2014 19:59:13 -0800 Subject: [PATCH 2/5] Make node creation more consistent in the parser. --- src/compiler/parser.ts | 89 +++++++++++++++++------------------------- 1 file changed, 35 insertions(+), 54 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index ea025bd2a62..1b35969de81 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1530,28 +1530,25 @@ module ts { } function parseSignature(kind: SyntaxKind, returnToken: SyntaxKind, returnTokenRequired: boolean): ParsedSignature { + var signature = {}; + fillSignature(kind, returnToken, returnTokenRequired, signature); + return signature; + } + + function fillSignature(kind: SyntaxKind, returnToken: SyntaxKind, returnTokenRequired: boolean, signature: ParsedSignature): void { if (kind === SyntaxKind.ConstructSignature) { parseExpected(SyntaxKind.NewKeyword); } - var typeParameters = parseTypeParameters(); - var parameters = parseParameterList(SyntaxKind.OpenParenToken, SyntaxKind.CloseParenToken); - - var type: TypeNode; + signature.typeParameters = parseTypeParameters(); + signature.parameters = parseParameterList(SyntaxKind.OpenParenToken, SyntaxKind.CloseParenToken); if (returnTokenRequired) { parseExpected(returnToken); - type = parseType(); + signature.type = parseType(); } - else if (parseOptional(returnToken)) - { - type = parseType(); + else if (parseOptional(returnToken)) { + signature.type = parseType(); } - - return { - typeParameters, - parameters, - type: type - }; } // Because we use this for index signatures as well, we sometimes use @@ -2966,13 +2963,12 @@ module ts { function parseFunctionDeclaration(pos?: number, flags?: NodeFlags): FunctionLikeDeclaration { var node = createNode(SyntaxKind.FunctionDeclaration, pos); - if (flags) node.flags = flags; + if (flags) { + node.flags = flags; + } parseExpected(SyntaxKind.FunctionKeyword); node.name = parseIdentifier(); - var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false); - node.typeParameters = sig.typeParameters; - node.parameters = sig.parameters; - node.type = sig.type; + fillSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false, node); node.body = parseFunctionBlockOrSemicolon(); return finishNode(node); } @@ -2980,18 +2976,13 @@ module ts { function parseConstructorDeclaration(pos: number, modifiers: ModifiersArray): ConstructorDeclaration { var node = createNode(SyntaxKind.Constructor, pos); setModifiers(node, modifiers); - parseExpected(SyntaxKind.ConstructorKeyword); - var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false); - node.typeParameters = sig.typeParameters; - node.parameters = sig.parameters; - node.type = sig.type; + fillSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false, node); node.body = parseFunctionBlockOrSemicolon(); - return finishNode(node); } - function parsePropertyMemberDeclaration(pos: number, modifiers: ModifiersArray): Declaration { + function parsePropertyMemberDeclaration(fullStart: number, modifiers: ModifiersArray): Declaration { var name = parsePropertyName(); var flags = modifiers ? modifiers.flags : 0; if (parseOptional(SyntaxKind.QuestionToken)) { @@ -3001,47 +2992,35 @@ module ts { } if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) { - var method = createNode(SyntaxKind.Method, pos); + var method = createNode(SyntaxKind.Method, fullStart); setModifiers(method, modifiers); - if (flags) { method.flags = flags; } method.name = name; - var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false); - method.typeParameters = sig.typeParameters; - method.parameters = sig.parameters; - method.type = sig.type; + fillSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false, method); method.body = parseFunctionBlockOrSemicolon(); - return finishNode(method); } else { - var property = createNode(SyntaxKind.Property, pos); + var property = createNode(SyntaxKind.Property, fullStart); setModifiers(property, modifiers); - if (flags) { property.flags = flags; } property.name = name; property.type = parseTypeAnnotation(); - property.initializer = parseInitializer(/*inParameter*/ false); parseSemicolon(); - return finishNode(property); } } - function parseMemberAccessorDeclaration(kind: SyntaxKind, pos: number, modifiers: ModifiersArray): MethodDeclaration { - var node = createNode(kind, pos); + function parseMemberAccessorDeclaration(kind: SyntaxKind, fullStart: number, modifiers: ModifiersArray): MethodDeclaration { + var node = createNode(kind, fullStart); setModifiers(node, modifiers); - node.name = parsePropertyName(); - var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false); - node.typeParameters = sig.typeParameters; - node.parameters = sig.parameters; - node.type = sig.type; + fillSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false, node); node.body = parseFunctionBlockOrSemicolon(); return finishNode(node); } @@ -3101,15 +3080,17 @@ module ts { var modifiers: ModifiersArray; while (true) { var modifierStart = scanner.getTokenPos(); - var modifierToken = token; + var modifierKind = token; - if (!parseAnyContextualModifier()) break; + if (!parseAnyContextualModifier()) { + break; + } if (!modifiers) { modifiers = []; } - flags |= modifierToFlag(modifierToken); - modifiers.push(finishNode(createNode(modifierToken, modifierStart))); + flags |= modifierToFlag(modifierKind); + modifiers.push(finishNode(createNode(modifierKind, modifierStart))); } if (modifiers) { modifiers.flags = flags; @@ -3118,22 +3099,22 @@ module ts { } function parseClassMemberDeclaration(): Declaration { - var pos = getNodePos(); + var fullStart = getNodePos(); var modifiers = parseModifiers(ModifierContext.ClassMembers); if (parseContextualModifier(SyntaxKind.GetKeyword)) { - return parseMemberAccessorDeclaration(SyntaxKind.GetAccessor, pos, modifiers); + return parseMemberAccessorDeclaration(SyntaxKind.GetAccessor, fullStart, modifiers); } if (parseContextualModifier(SyntaxKind.SetKeyword)) { - return parseMemberAccessorDeclaration(SyntaxKind.SetAccessor, pos, modifiers); + return parseMemberAccessorDeclaration(SyntaxKind.SetAccessor, fullStart, modifiers); } if (token === SyntaxKind.ConstructorKeyword) { - return parseConstructorDeclaration(pos, modifiers); + return parseConstructorDeclaration(fullStart, modifiers); } if (token >= SyntaxKind.Identifier || token === SyntaxKind.StringLiteral || token === SyntaxKind.NumericLiteral) { - return parsePropertyMemberDeclaration(pos, modifiers); + return parsePropertyMemberDeclaration(fullStart, modifiers); } if (token === SyntaxKind.OpenBracketToken) { - return parseIndexSignatureMember(modifiers, pos); + return parseIndexSignatureMember(modifiers, fullStart); } // 'isClassMemberStart' should have hinted not to attempt parsing. From 9ff553e5e8300eb47bdd3024b9873b4a5cde891b Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 21 Nov 2014 20:23:35 -0800 Subject: [PATCH 3/5] Simplify parser. --- src/compiler/parser.ts | 36 ++++++++++++------------------------ 1 file changed, 12 insertions(+), 24 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 1b35969de81..b50e30de38a 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2775,10 +2775,6 @@ module ts { return finishNode(node); } - function isIterationStatementStart(): boolean { - return token === SyntaxKind.WhileKeyword || token === SyntaxKind.DoKeyword || token === SyntaxKind.ForKeyword; - } - function isLabel(): boolean { return isIdentifier() && lookAhead(() => nextToken() === SyntaxKind.ColonToken); } @@ -2787,8 +2783,7 @@ module ts { var node = createNode(SyntaxKind.LabeledStatement); node.label = parseIdentifier(); parseExpected(SyntaxKind.ColonToken); - - node.statement = isLabel() ? parseLabeledStatement() : parseStatement(); + node.statement = parseStatement(); return finishNode(node); } @@ -2869,9 +2864,9 @@ module ts { case SyntaxKind.LetKeyword: case SyntaxKind.ConstKeyword: // const here should always be parsed as const declaration because of check in 'isStatement' - return parseVariableStatement(); + return parseVariableStatement(scanner.getStartPos(), /*modifiers:*/ undefined); case SyntaxKind.FunctionKeyword: - return parseFunctionDeclaration(); + return parseFunctionDeclaration(scanner.getStartPos(), /*modifiers:*/ undefined); case SyntaxKind.SemicolonToken: return parseEmptyStatement(); case SyntaxKind.IfKeyword: @@ -2928,10 +2923,7 @@ module ts { node.flags = flags; node.name = parseIdentifier(); node.type = parseTypeAnnotation(); - - // Issue any initializer-related errors on the equals token node.initializer = parseInitializer(/*inParameter*/ false, noIn); - return finishNode(node); } @@ -2939,11 +2931,9 @@ module ts { return parseDelimitedList(ParsingContext.VariableDeclarations, () => parseVariableDeclaration(flags, noIn)); } - function parseVariableStatement(pos?: number, flags?: NodeFlags): VariableStatement { - var node = createNode(SyntaxKind.VariableStatement, pos); - if (flags) { - node.flags = flags; - } + function parseVariableStatement(fullStart: number, modifiers: ModifiersArray): VariableStatement { + var node = createNode(SyntaxKind.VariableStatement, fullStart); + setModifiers(node, modifiers); if (token === SyntaxKind.LetKeyword) { node.flags |= NodeFlags.Let; @@ -2961,11 +2951,9 @@ module ts { return finishNode(node); } - function parseFunctionDeclaration(pos?: number, flags?: NodeFlags): FunctionLikeDeclaration { - var node = createNode(SyntaxKind.FunctionDeclaration, pos); - if (flags) { - node.flags = flags; - } + function parseFunctionDeclaration(fullStart: number, modifiers: ModifiersArray): FunctionLikeDeclaration { + var node = createNode(SyntaxKind.FunctionDeclaration, fullStart); + setModifiers(node, modifiers); parseExpected(SyntaxKind.FunctionKeyword); node.name = parseIdentifier(); fillSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false, node); @@ -3305,7 +3293,7 @@ module ts { switch (token) { case SyntaxKind.VarKeyword: case SyntaxKind.LetKeyword: - result = parseVariableStatement(fullStart, flags); + result = parseVariableStatement(fullStart, modifiers); break; case SyntaxKind.ConstKeyword: var isConstEnum = lookAhead(() => nextToken() === SyntaxKind.EnumKeyword); @@ -3313,11 +3301,11 @@ module ts { result = parseAndCheckEnumDeclaration(fullStart, flags | NodeFlags.Const); } else { - result = parseVariableStatement(fullStart, flags); + result = parseVariableStatement(fullStart, modifiers); } break; case SyntaxKind.FunctionKeyword: - result = parseFunctionDeclaration(fullStart, flags); + result = parseFunctionDeclaration(fullStart, modifiers); break; case SyntaxKind.ClassKeyword: result = parseClassDeclaration(fullStart, modifiers); From f61f70abf09850bfe3184ca264a5d6395b91ad88 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 21 Nov 2014 20:36:32 -0800 Subject: [PATCH 4/5] More parser simplification. --- src/compiler/parser.ts | 62 ++++++++++++++++++++++-------------------- 1 file changed, 33 insertions(+), 29 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index b50e30de38a..19489284edc 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1559,10 +1559,7 @@ module ts { function parseSignatureMember(kind: SyntaxKind, returnToken: SyntaxKind): SignatureDeclaration { var node = createNode(kind); - var sig = parseSignature(kind, returnToken, /* returnTokenRequired */ false); - node.typeParameters = sig.typeParameters; - node.parameters = sig.parameters; - node.type = sig.type; + fillSignature(kind, returnToken, /* returnTokenRequired */ false, node); parseSemicolon(); return finishNode(node); } @@ -1578,24 +1575,29 @@ module ts { } function parsePropertyOrMethod(): Declaration { - var node = createNode(SyntaxKind.Unknown); - node.name = parsePropertyName(); + var fullStart = scanner.getStartPos(); + var name = parsePropertyName(); + var flags = 0; if (parseOptional(SyntaxKind.QuestionToken)) { - node.flags |= NodeFlags.QuestionMark; + flags = NodeFlags.QuestionMark; } + if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) { - node.kind = SyntaxKind.Method; - var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false); - (node).typeParameters = sig.typeParameters; - (node).parameters = sig.parameters; - (node).type = sig.type; + var method = createNode(SyntaxKind.Method, fullStart); + method.name = name; + method.flags = flags; + fillSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken, /* returnTokenRequired */ false, method); + parseSemicolon(); + return finishNode(method); } else { - node.kind = SyntaxKind.Property; - (node).type = parseTypeAnnotation(); + var property = createNode(SyntaxKind.Property, fullStart); + property.name = name; + property.flags = flags; + property.type = parseTypeAnnotation(); + parseSemicolon(); + return finishNode(property); } - parseSemicolon(); - return finishNode(node); } function isStartOfTypeMember(): boolean { @@ -1633,14 +1635,21 @@ module ts { function parseTypeLiteral(): TypeLiteralNode { var node = createNode(SyntaxKind.TypeLiteral); + node.members = parseObjectType(); + return finishNode(node); + } + + function parseObjectType(): NodeArray { + var members: NodeArray; if (parseExpected(SyntaxKind.OpenBraceToken)) { - node.members = parseList(ParsingContext.TypeMembers, /*checkForStrictMode*/ false, parseTypeMember); + members = parseList(ParsingContext.TypeMembers, /*checkForStrictMode*/ false, parseTypeMember); parseExpected(SyntaxKind.CloseBraceToken); } else { - node.members = createMissingList(); + members = createMissingList(); } - return finishNode(node); + + return members; } function parseTupleType(): TupleTypeNode { @@ -1658,15 +1667,10 @@ module ts { } function parseFunctionType(typeKind: SyntaxKind): SignatureDeclaration { - var member = createNode(typeKind); - var sig = parseSignature(typeKind === SyntaxKind.FunctionType ? SyntaxKind.CallSignature : SyntaxKind.ConstructSignature, - SyntaxKind.EqualsGreaterThanToken, /* returnTokenRequired */ true); - - member.typeParameters = sig.typeParameters; - member.parameters = sig.parameters; - member.type = sig.type; - finishNode(member); - return member; + var node = createNode(typeKind); + fillSignature(typeKind === SyntaxKind.FunctionType ? SyntaxKind.CallSignature : SyntaxKind.ConstructSignature, + SyntaxKind.EqualsGreaterThanToken, /* returnTokenRequired */ true, node); + return finishNode(node); } function parseKeywordAndNoDot(): Node { @@ -3141,7 +3145,7 @@ module ts { if (parseOptional(SyntaxKind.ExtendsKeyword)) { node.baseTypes = parseDelimitedList(ParsingContext.BaseTypeReferences, parseTypeReference); } - node.members = parseTypeLiteral().members; + node.members = parseObjectType(); return finishNode(node); } From 932aa9457364d2f63f49b08e235f6ae87b363162 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Sat, 22 Nov 2014 12:11:42 -0800 Subject: [PATCH 5/5] More parser consistency. --- src/compiler/parser.ts | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 19489284edc..7389ebd0329 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1319,13 +1319,6 @@ module ts { return result; } - function createNodeArray(node: T): NodeArray { - var result = >[node]; - result.pos = node.pos; - result.end = node.end; - return result; - } - function parseBracketedList(kind: ParsingContext, parseElement: () => T, startToken: SyntaxKind, endToken: SyntaxKind): NodeArray { if (parseExpected(startToken)) { var result = parseDelimitedList(kind, parseElement); @@ -1478,7 +1471,11 @@ module ts { } function parseParameterType(): TypeNode { - return parseOptional(SyntaxKind.ColonToken) ? token === SyntaxKind.StringLiteral ? parseStringLiteral() : parseType() : undefined; + return parseOptional(SyntaxKind.ColonToken) + ? token === SyntaxKind.StringLiteral + ? parseStringLiteral() + : parseType() + : undefined; } function isStartOfParameter(): boolean { @@ -1492,7 +1489,7 @@ module ts { } } - function parseParameter(flags: NodeFlags = 0): ParameterDeclaration { + function parseParameter(): ParameterDeclaration { var node = createNode(SyntaxKind.Parameter); var modifiers = parseModifiers(ModifierContext.Parameters); setModifiers(node, modifiers); @@ -1564,10 +1561,9 @@ module ts { return finishNode(node); } - function parseIndexSignatureMember(modifiers: ModifiersArray, pos?: number): SignatureDeclaration { - var node = createNode(SyntaxKind.IndexSignature, pos); + function parseIndexSignatureMember(fullStart: number, modifiers: ModifiersArray): SignatureDeclaration { + var node = createNode(SyntaxKind.IndexSignature, fullStart); setModifiers(node, modifiers); - node.parameters = parseParameterList(SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken); node.type = parseTypeAnnotation(); parseSemicolon(); @@ -1618,7 +1614,7 @@ module ts { case SyntaxKind.LessThanToken: return parseSignatureMember(SyntaxKind.CallSignature, SyntaxKind.ColonToken); case SyntaxKind.OpenBracketToken: - return parseIndexSignatureMember(/*modifiers:*/ undefined); + return parseIndexSignatureMember(scanner.getStartPos(), /*modifiers:*/ undefined); case SyntaxKind.NewKeyword: if (lookAhead(() => nextToken() === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken)) { return parseSignatureMember(SyntaxKind.ConstructSignature, SyntaxKind.ColonToken); @@ -3106,7 +3102,7 @@ module ts { return parsePropertyMemberDeclaration(fullStart, modifiers); } if (token === SyntaxKind.OpenBracketToken) { - return parseIndexSignatureMember(modifiers, fullStart); + return parseIndexSignatureMember(fullStart, modifiers); } // 'isClassMemberStart' should have hinted not to attempt parsing.