Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1307 from Microsoft/parserImprovements

Browse Source 
Simplify parser.
This commit is contained in:
CyrusNajmabadi
2014-11-29 16:38:53 -08:00
parent e70005b583 7152d37ea2
commit b4962594ac
12 changed files with 162 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/services/syntax/SyntaxGenerator.js
+75 -76
View File
@@ -555,80 +555,79 @@ var TypeScript;
SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 143] = "MemberFunctionDeclaration";
SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 144] = "MemberVariableDeclaration";
SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 145] = "ConstructorDeclaration";
SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 146] = "IndexMemberDeclaration";
SyntaxKind[SyntaxKind["GetAccessor"] = 147] = "GetAccessor";
SyntaxKind[SyntaxKind["SetAccessor"] = 148] = "SetAccessor";
SyntaxKind[SyntaxKind["PropertySignature"] = 149] = "PropertySignature";
SyntaxKind[SyntaxKind["CallSignature"] = 150] = "CallSignature";
SyntaxKind[SyntaxKind["ConstructSignature"] = 151] = "ConstructSignature";
SyntaxKind[SyntaxKind["IndexSignature"] = 152] = "IndexSignature";
SyntaxKind[SyntaxKind["MethodSignature"] = 153] = "MethodSignature";
SyntaxKind[SyntaxKind["Block"] = 154] = "Block";
SyntaxKind[SyntaxKind["IfStatement"] = 155] = "IfStatement";
SyntaxKind[SyntaxKind["VariableStatement"] = 156] = "VariableStatement";
SyntaxKind[SyntaxKind["ExpressionStatement"] = 157] = "ExpressionStatement";
SyntaxKind[SyntaxKind["ReturnStatement"] = 158] = "ReturnStatement";
SyntaxKind[SyntaxKind["SwitchStatement"] = 159] = "SwitchStatement";
SyntaxKind[SyntaxKind["BreakStatement"] = 160] = "BreakStatement";
SyntaxKind[SyntaxKind["ContinueStatement"] = 161] = "ContinueStatement";
SyntaxKind[SyntaxKind["ForStatement"] = 162] = "ForStatement";
SyntaxKind[SyntaxKind["ForInStatement"] = 163] = "ForInStatement";
SyntaxKind[SyntaxKind["EmptyStatement"] = 164] = "EmptyStatement";
SyntaxKind[SyntaxKind["ThrowStatement"] = 165] = "ThrowStatement";
SyntaxKind[SyntaxKind["WhileStatement"] = 166] = "WhileStatement";
SyntaxKind[SyntaxKind["TryStatement"] = 167] = "TryStatement";
SyntaxKind[SyntaxKind["LabeledStatement"] = 168] = "LabeledStatement";
SyntaxKind[SyntaxKind["DoStatement"] = 169] = "DoStatement";
SyntaxKind[SyntaxKind["DebuggerStatement"] = 170] = "DebuggerStatement";
SyntaxKind[SyntaxKind["WithStatement"] = 171] = "WithStatement";
SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 172] = "PrefixUnaryExpression";
SyntaxKind[SyntaxKind["DeleteExpression"] = 173] = "DeleteExpression";
SyntaxKind[SyntaxKind["TypeOfExpression"] = 174] = "TypeOfExpression";
SyntaxKind[SyntaxKind["VoidExpression"] = 175] = "VoidExpression";
SyntaxKind[SyntaxKind["ConditionalExpression"] = 176] = "ConditionalExpression";
SyntaxKind[SyntaxKind["BinaryExpression"] = 177] = "BinaryExpression";
SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 178] = "PostfixUnaryExpression";
SyntaxKind[SyntaxKind["MemberAccessExpression"] = 179] = "MemberAccessExpression";
SyntaxKind[SyntaxKind["InvocationExpression"] = 180] = "InvocationExpression";
SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 181] = "ArrayLiteralExpression";
SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 182] = "ObjectLiteralExpression";
SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 183] = "ObjectCreationExpression";
SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 184] = "ParenthesizedExpression";
SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 185] = "ParenthesizedArrowFunctionExpression";
SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 186] = "SimpleArrowFunctionExpression";
SyntaxKind[SyntaxKind["CastExpression"] = 187] = "CastExpression";
SyntaxKind[SyntaxKind["ElementAccessExpression"] = 188] = "ElementAccessExpression";
SyntaxKind[SyntaxKind["FunctionExpression"] = 189] = "FunctionExpression";
SyntaxKind[SyntaxKind["OmittedExpression"] = 190] = "OmittedExpression";
SyntaxKind[SyntaxKind["TemplateExpression"] = 191] = "TemplateExpression";
SyntaxKind[SyntaxKind["TemplateAccessExpression"] = 192] = "TemplateAccessExpression";
SyntaxKind[SyntaxKind["YieldExpression"] = 193] = "YieldExpression";
SyntaxKind[SyntaxKind["AwaitExpression"] = 194] = "AwaitExpression";
SyntaxKind[SyntaxKind["VariableDeclaration"] = 195] = "VariableDeclaration";
SyntaxKind[SyntaxKind["VariableDeclarator"] = 196] = "VariableDeclarator";
SyntaxKind[SyntaxKind["ArgumentList"] = 197] = "ArgumentList";
SyntaxKind[SyntaxKind["ParameterList"] = 198] = "ParameterList";
SyntaxKind[SyntaxKind["TypeArgumentList"] = 199] = "TypeArgumentList";
SyntaxKind[SyntaxKind["TypeParameterList"] = 200] = "TypeParameterList";
SyntaxKind[SyntaxKind["HeritageClause"] = 201] = "HeritageClause";
SyntaxKind[SyntaxKind["EqualsValueClause"] = 202] = "EqualsValueClause";
SyntaxKind[SyntaxKind["CaseSwitchClause"] = 203] = "CaseSwitchClause";
SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 204] = "DefaultSwitchClause";
SyntaxKind[SyntaxKind["ElseClause"] = 205] = "ElseClause";
SyntaxKind[SyntaxKind["CatchClause"] = 206] = "CatchClause";
SyntaxKind[SyntaxKind["FinallyClause"] = 207] = "FinallyClause";
SyntaxKind[SyntaxKind["TemplateClause"] = 208] = "TemplateClause";
SyntaxKind[SyntaxKind["TypeParameter"] = 209] = "TypeParameter";
SyntaxKind[SyntaxKind["Constraint"] = 210] = "Constraint";
SyntaxKind[SyntaxKind["Parameter"] = 211] = "Parameter";
SyntaxKind[SyntaxKind["EnumElement"] = 212] = "EnumElement";
SyntaxKind[SyntaxKind["TypeAnnotation"] = 213] = "TypeAnnotation";
SyntaxKind[SyntaxKind["ExpressionBody"] = 214] = "ExpressionBody";
SyntaxKind[SyntaxKind["ComputedPropertyName"] = 215] = "ComputedPropertyName";
SyntaxKind[SyntaxKind["PropertyAssignment"] = 216] = "PropertyAssignment";
SyntaxKind[SyntaxKind["TypeAlias"] = 217] = "TypeAlias";
SyntaxKind[SyntaxKind["ExternalModuleReference"] = 218] = "ExternalModuleReference";
SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 219] = "ModuleNameModuleReference";
SyntaxKind[SyntaxKind["GetAccessor"] = 146] = "GetAccessor";
SyntaxKind[SyntaxKind["SetAccessor"] = 147] = "SetAccessor";
SyntaxKind[SyntaxKind["PropertySignature"] = 148] = "PropertySignature";
SyntaxKind[SyntaxKind["CallSignature"] = 149] = "CallSignature";
SyntaxKind[SyntaxKind["ConstructSignature"] = 150] = "ConstructSignature";
SyntaxKind[SyntaxKind["IndexSignature"] = 151] = "IndexSignature";
SyntaxKind[SyntaxKind["MethodSignature"] = 152] = "MethodSignature";
SyntaxKind[SyntaxKind["Block"] = 153] = "Block";
SyntaxKind[SyntaxKind["IfStatement"] = 154] = "IfStatement";
SyntaxKind[SyntaxKind["VariableStatement"] = 155] = "VariableStatement";
SyntaxKind[SyntaxKind["ExpressionStatement"] = 156] = "ExpressionStatement";
SyntaxKind[SyntaxKind["ReturnStatement"] = 157] = "ReturnStatement";
SyntaxKind[SyntaxKind["SwitchStatement"] = 158] = "SwitchStatement";
SyntaxKind[SyntaxKind["BreakStatement"] = 159] = "BreakStatement";
SyntaxKind[SyntaxKind["ContinueStatement"] = 160] = "ContinueStatement";
SyntaxKind[SyntaxKind["ForStatement"] = 161] = "ForStatement";
SyntaxKind[SyntaxKind["ForInStatement"] = 162] = "ForInStatement";
SyntaxKind[SyntaxKind["EmptyStatement"] = 163] = "EmptyStatement";
SyntaxKind[SyntaxKind["ThrowStatement"] = 164] = "ThrowStatement";
SyntaxKind[SyntaxKind["WhileStatement"] = 165] = "WhileStatement";
SyntaxKind[SyntaxKind["TryStatement"] = 166] = "TryStatement";
SyntaxKind[SyntaxKind["LabeledStatement"] = 167] = "LabeledStatement";
SyntaxKind[SyntaxKind["DoStatement"] = 168] = "DoStatement";
SyntaxKind[SyntaxKind["DebuggerStatement"] = 169] = "DebuggerStatement";
SyntaxKind[SyntaxKind["WithStatement"] = 170] = "WithStatement";
SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 171] = "PrefixUnaryExpression";
SyntaxKind[SyntaxKind["DeleteExpression"] = 172] = "DeleteExpression";
SyntaxKind[SyntaxKind["TypeOfExpression"] = 173] = "TypeOfExpression";
SyntaxKind[SyntaxKind["VoidExpression"] = 174] = "VoidExpression";
SyntaxKind[SyntaxKind["ConditionalExpression"] = 175] = "ConditionalExpression";
SyntaxKind[SyntaxKind["BinaryExpression"] = 176] = "BinaryExpression";
SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 177] = "PostfixUnaryExpression";
SyntaxKind[SyntaxKind["MemberAccessExpression"] = 178] = "MemberAccessExpression";
SyntaxKind[SyntaxKind["InvocationExpression"] = 179] = "InvocationExpression";
SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 180] = "ArrayLiteralExpression";
SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 181] = "ObjectLiteralExpression";
SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 182] = "ObjectCreationExpression";
SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 183] = "ParenthesizedExpression";
SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 184] = "ParenthesizedArrowFunctionExpression";
SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 185] = "SimpleArrowFunctionExpression";
SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 186] = "TypeAssertionExpression";
SyntaxKind[SyntaxKind["ElementAccessExpression"] = 187] = "ElementAccessExpression";
SyntaxKind[SyntaxKind["FunctionExpression"] = 188] = "FunctionExpression";
SyntaxKind[SyntaxKind["OmittedExpression"] = 189] = "OmittedExpression";
SyntaxKind[SyntaxKind["TemplateExpression"] = 190] = "TemplateExpression";
SyntaxKind[SyntaxKind["TemplateAccessExpression"] = 191] = "TemplateAccessExpression";
SyntaxKind[SyntaxKind["YieldExpression"] = 192] = "YieldExpression";
SyntaxKind[SyntaxKind["AwaitExpression"] = 193] = "AwaitExpression";
SyntaxKind[SyntaxKind["VariableDeclaration"] = 194] = "VariableDeclaration";
SyntaxKind[SyntaxKind["VariableDeclarator"] = 195] = "VariableDeclarator";
SyntaxKind[SyntaxKind["ArgumentList"] = 196] = "ArgumentList";
SyntaxKind[SyntaxKind["ParameterList"] = 197] = "ParameterList";
SyntaxKind[SyntaxKind["TypeArgumentList"] = 198] = "TypeArgumentList";
SyntaxKind[SyntaxKind["TypeParameterList"] = 199] = "TypeParameterList";
SyntaxKind[SyntaxKind["HeritageClause"] = 200] = "HeritageClause";
SyntaxKind[SyntaxKind["EqualsValueClause"] = 201] = "EqualsValueClause";
SyntaxKind[SyntaxKind["CaseSwitchClause"] = 202] = "CaseSwitchClause";
SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 203] = "DefaultSwitchClause";
SyntaxKind[SyntaxKind["ElseClause"] = 204] = "ElseClause";
SyntaxKind[SyntaxKind["CatchClause"] = 205] = "CatchClause";
SyntaxKind[SyntaxKind["FinallyClause"] = 206] = "FinallyClause";
SyntaxKind[SyntaxKind["TemplateClause"] = 207] = "TemplateClause";
SyntaxKind[SyntaxKind["TypeParameter"] = 208] = "TypeParameter";
SyntaxKind[SyntaxKind["Constraint"] = 209] = "Constraint";
SyntaxKind[SyntaxKind["Parameter"] = 210] = "Parameter";
SyntaxKind[SyntaxKind["EnumElement"] = 211] = "EnumElement";
SyntaxKind[SyntaxKind["TypeAnnotation"] = 212] = "TypeAnnotation";
SyntaxKind[SyntaxKind["ExpressionBody"] = 213] = "ExpressionBody";
SyntaxKind[SyntaxKind["ComputedPropertyName"] = 214] = "ComputedPropertyName";
SyntaxKind[SyntaxKind["PropertyAssignment"] = 215] = "PropertyAssignment";
SyntaxKind[SyntaxKind["TypeAlias"] = 216] = "TypeAlias";
SyntaxKind[SyntaxKind["ExternalModuleReference"] = 217] = "ExternalModuleReference";
SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 218] = "ModuleNameModuleReference";
SyntaxKind[SyntaxKind["FirstStandardKeyword"] = 17] = "FirstStandardKeyword";
SyntaxKind[SyntaxKind["LastStandardKeyword"] = 45] = "LastStandardKeyword";
SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = 46] = "FirstFutureReservedKeyword";
@@ -648,7 +647,7 @@ var TypeScript;
SyntaxKind[SyntaxKind["FirstTrivia"] = 2] = "FirstTrivia";
SyntaxKind[SyntaxKind["LastTrivia"] = 6] = "LastTrivia";
SyntaxKind[SyntaxKind["FirstNode"] = 125] = "FirstNode";
SyntaxKind[SyntaxKind["LastNode"] = 219] = "LastNode";
SyntaxKind[SyntaxKind["LastNode"] = 218] = "LastNode";
})(TypeScript.SyntaxKind || (TypeScript.SyntaxKind = {}));
var SyntaxKind = TypeScript.SyntaxKind;
})(TypeScript || (TypeScript = {}));
@@ -1741,7 +1740,7 @@ var definitions = [
]
},
{
name: 'CastExpressionSyntax',
name: 'TypeAssertionExpressionSyntax',
baseType: 'ISyntaxNode',
interfaces: ['IUnaryExpressionSyntax'],
children: [
src/services/syntax/SyntaxGenerator.js.map
+4
View File
File diff suppressed because one or more lines are too long
src/services/syntax/parser.ts
+70 -116
View File
@@ -1019,7 +1019,7 @@ module TypeScript.Parser {
_currentToken.hasLeadingNewLine()) {
var token1 = peekToken(1);
if (!existsNewLineBetweenTokens(_currentToken, token1, source.text) &&
if (!token1.hasLeadingNewLine() &&
SyntaxFacts.isIdentifierNameOrAnyKeyword(token1)) {
return createMissingToken(SyntaxKind.IdentifierName, _currentToken);
@@ -1555,8 +1555,7 @@ module TypeScript.Parser {
// Then we *should* parse it as a property name, as ASI takes effect here.
if (isModifier(_currentToken, /*index:*/ 0)) {
var token1 = peekToken(1);
if (!existsNewLineBetweenTokens(_currentToken, token1, source.text) &&
isPropertyNameToken(token1, inErrorRecovery)) {
if (!token1.hasLeadingNewLine() && isPropertyNameToken(token1, inErrorRecovery)) {
return false;
}
@@ -2238,7 +2237,7 @@ module TypeScript.Parser {
return new OmittedExpressionSyntax(contextFlags);
}
return allowInAnd(tryParseAssignmentExpressionOrHigher);
return isExpression(currentToken()) ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
}
function isExpression(currentToken: ISyntaxToken): boolean {
@@ -2521,19 +2520,11 @@ module TypeScript.Parser {
return leftOperand;
}
function tryParseAssignmentExpressionOrHigher(): IExpressionSyntax {
return tryParseAssignmentExpressionOrHigherWorker(/*force:*/ false);
}
function parseAssignmentExpressionOrHigher(): IExpressionSyntax {
return tryParseAssignmentExpressionOrHigherWorker(/*force:*/ true);
}
// Called when you need to parse an expression, but you do not want to allow 'CommaExpressions'.
// i.e. if you have "var a = 1, b = 2" then when we parse '1' we want to parse with higher
// precedence than 'comma'. Otherwise we'll get: "var a = (1, (b = 2))", instead of
// "var a = (1), b = (2)");
function tryParseAssignmentExpressionOrHigherWorker(force: boolean): IExpressionSyntax {
function parseAssignmentExpressionOrHigher(): IExpressionSyntax {
// AssignmentExpression[in,yield]:
// 1) ConditionalExpression[?in,?yield]
// 2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -2567,11 +2558,7 @@ module TypeScript.Parser {
// Otherwise, we try to parse out the conditional expression bit. We want to allow any
// binary expression here, so we pass in the 'lowest' precedence here so that it matches
// and consumes anything.
var leftOperand = tryParseBinaryExpressionOrHigher(_currentToken, force, BinaryExpressionPrecedence.Lowest);
if (leftOperand === undefined) {
return undefined;
}
var leftOperand = parseBinaryExpressionOrHigher(_currentToken, BinaryExpressionPrecedence.Lowest);
if (SyntaxUtilities.isLeftHandSizeExpression(leftOperand)) {
// Note: we call currentOperatorToken so that we get an appropriately merged token
// for cases like > > = becoming >>=
@@ -2615,7 +2602,7 @@ module TypeScript.Parser {
}
// Not an 'await' expression. Parse this with our normal postfix parsing rules.
return tryParsePostfixExpressionOrHigher(awaitKeyword, /*force:*/ true);
return parsePostfixExpressionOrHigher(awaitKeyword);
}
function parseAwaitExpression(awaitKeyword: ISyntaxToken): AwaitExpressionSyntax {
@@ -2728,7 +2715,7 @@ module TypeScript.Parser {
: tryParseParenthesizedArrowFunctionExpression();
}
function tryParseUnaryExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): IUnaryExpressionSyntax {
function parseUnaryExpressionOrHigher(_currentToken: ISyntaxToken): IUnaryExpressionSyntax {
var currentTokenKind = _currentToken.kind;
switch (currentTokenKind) {
@@ -2738,7 +2725,7 @@ module TypeScript.Parser {
case SyntaxKind.ExclamationToken:
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
return new PrefixUnaryExpressionSyntax(contextFlags, consumeToken(_currentToken), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
return new PrefixUnaryExpressionSyntax(contextFlags, consumeToken(_currentToken), parseUnaryExpressionOrHigher(currentToken()));
case SyntaxKind.TypeOfKeyword:
return parseTypeOfExpression(_currentToken);
case SyntaxKind.VoidKeyword:
@@ -2746,15 +2733,15 @@ module TypeScript.Parser {
case SyntaxKind.DeleteKeyword:
return parseDeleteExpression(_currentToken);
case SyntaxKind.LessThanToken:
return parseCastExpression(_currentToken);
return parseTypeAssertionExpression(_currentToken);
case SyntaxKind.AwaitKeyword:
return parsePossibleAwaitExpression(_currentToken);
default:
return tryParsePostfixExpressionOrHigher(_currentToken, force);
return parsePostfixExpressionOrHigher(_currentToken);
}
}
function tryParseBinaryExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean, precedence: BinaryExpressionPrecedence): IExpressionSyntax {
function parseBinaryExpressionOrHigher(_currentToken: ISyntaxToken, precedence: BinaryExpressionPrecedence): IExpressionSyntax {
// The binary expressions are incredibly left recursive in their definitions. We
// clearly can't implement that through recursion. So, instead, we first bottom out
// of all the recursion by jumping to this production and consuming a UnaryExpression
@@ -2762,10 +2749,7 @@ module TypeScript.Parser {
//
// MultiplicativeExpression: See 11.5
// UnaryExpression
var leftOperand = tryParseUnaryExpressionOrHigher(_currentToken, force);
if (leftOperand === undefined) {
return undefined;
}
var leftOperand = parseUnaryExpressionOrHigher(_currentToken);
// We then pop up the stack consuming the other side of the binary exprssion if it exists.
return parseBinaryExpressionRest(precedence, leftOperand);
@@ -2829,7 +2813,7 @@ module TypeScript.Parser {
// Now skip the operator token we're on.
leftOperand = new BinaryExpressionSyntax(contextFlags, leftOperand, consumeToken(operatorToken),
tryParseBinaryExpressionOrHigher(currentToken(), /*force:*/ true, newPrecedence));
parseBinaryExpressionOrHigher(currentToken(), newPrecedence));
}
return leftOperand;
@@ -2851,7 +2835,7 @@ module TypeScript.Parser {
return token0;
}
function tryParseMemberExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): IMemberExpressionSyntax {
function parseMemberExpressionOrHigher(_currentToken: ISyntaxToken): IMemberExpressionSyntax {
// Note: to make our lives simpler, we decompose the the NewExpression productions and
// place ObjectCreationExpression and FunctionExpression into PrimaryExpression.
// like so:
@@ -2899,16 +2883,38 @@ module TypeScript.Parser {
//
// Because CallExpression and MemberExpression are left recursive, we need to bottom out
// of the recursion immediately. So we parse out a primary expression to start with.
var expression: IMemberExpressionSyntax = tryParsePrimaryExpression(_currentToken, force);
if (expression === undefined) {
return undefined;
}
var expression = parsePrimaryExpression(_currentToken);
return <IMemberExpressionSyntax>parseMemberExpressionRest(expression);
}
return parseMemberExpressionRest(expression);
function parseMemberExpressionRest(expression: ILeftHandSideExpressionSyntax): ILeftHandSideExpressionSyntax {
while (true) {
var _currentToken = currentToken();
var currentTokenKind = _currentToken.kind;
switch (currentTokenKind) {
case SyntaxKind.OpenBracketToken:
expression = parseElementAccessExpression(expression, _currentToken);
continue;
case SyntaxKind.DotToken:
expression = new MemberAccessExpressionSyntax(contextFlags, expression, consumeToken(_currentToken), eatIdentifierNameToken());
continue;
case SyntaxKind.NoSubstitutionTemplateToken:
case SyntaxKind.TemplateStartToken:
expression = new TemplateAccessExpressionSyntax(contextFlags, expression, parseTemplateExpression(_currentToken));
continue;
}
return expression;
}
}
function parseCallExpressionRest(expression: ILeftHandSideExpressionSyntax): ILeftHandSideExpressionSyntax {
while (true) {
expression = parseMemberExpressionRest(expression);
var _currentToken = currentToken();
var currentTokenKind = _currentToken.kind;
@@ -2929,50 +2935,13 @@ module TypeScript.Parser {
expression = new InvocationExpressionSyntax(contextFlags, expression, argumentList);
continue;
case SyntaxKind.OpenBracketToken:
expression = parseElementAccessExpression(expression, _currentToken);
continue;
case SyntaxKind.DotToken:
expression = new MemberAccessExpressionSyntax(contextFlags, expression, consumeToken(_currentToken), eatIdentifierNameToken());
continue;
case SyntaxKind.NoSubstitutionTemplateToken:
case SyntaxKind.TemplateStartToken:
expression = new TemplateAccessExpressionSyntax(contextFlags, expression, parseTemplateExpression(_currentToken));
continue;
}
return expression;
}
}
function parseMemberExpressionRest(expression: IMemberExpressionSyntax): IMemberExpressionSyntax {
while (true) {
var _currentToken = currentToken();
var currentTokenKind = _currentToken.kind;
switch (currentTokenKind) {
case SyntaxKind.OpenBracketToken:
expression = parseElementAccessExpression(expression, _currentToken);
continue;
case SyntaxKind.DotToken:
expression = new MemberAccessExpressionSyntax(contextFlags, expression, consumeToken(_currentToken), eatIdentifierNameToken());
continue;
case SyntaxKind.NoSubstitutionTemplateToken:
case SyntaxKind.TemplateStartToken:
expression = new TemplateAccessExpressionSyntax(contextFlags, expression, parseTemplateExpression(_currentToken));
continue;
}
return expression;
}
}
function tryParseLeftHandSideExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): ILeftHandSideExpressionSyntax {
function parseLeftHandSideExpressionOrHigher(_currentToken: ISyntaxToken): ILeftHandSideExpressionSyntax {
// Original Ecma:
// LeftHandSideExpression: See 11.2
// NewExpression
@@ -3004,16 +2973,9 @@ module TypeScript.Parser {
// completes the LeftHandSideExpression, or starts the beginning of the first four
// CallExpression productions.
var expression: ILeftHandSideExpressionSyntax = undefined;
if (_currentToken.kind === SyntaxKind.SuperKeyword) {
expression = parseSuperExpression(_currentToken);
}
else {
expression = tryParseMemberExpressionOrHigher(_currentToken, force);
if (expression === undefined) {
return undefined;
}
}
var expression: ILeftHandSideExpressionSyntax = _currentToken.kind === SyntaxKind.SuperKeyword
? parseSuperExpression(_currentToken)
: parseMemberExpressionOrHigher(_currentToken);
// Now, we *may* be complete. However, we might have consumed the start of a
// CallExpression. As such, we need to consume the rest of it here to be complete.
@@ -3031,11 +2993,8 @@ module TypeScript.Parser {
: new MemberAccessExpressionSyntax(contextFlags, expression, eatToken(SyntaxKind.DotToken), eatIdentifierNameToken());
}
function tryParsePostfixExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): IPostfixExpressionSyntax {
var expression = tryParseLeftHandSideExpressionOrHigher(_currentToken, force);
if (expression === undefined) {
return undefined;
}
function parsePostfixExpressionOrHigher(_currentToken: ISyntaxToken): IPostfixExpressionSyntax {
var expression = parseLeftHandSideExpressionOrHigher(_currentToken);
var _currentToken = currentToken();
var currentTokenKind = _currentToken.kind;
@@ -3136,7 +3095,7 @@ module TypeScript.Parser {
// cause a missing identiifer to be created), so that we will then consume the
// comma and the following list items).
var force = currentToken().kind === SyntaxKind.CommaToken;
return allowInAnd(force ? parseAssignmentExpressionOrHigher : tryParseAssignmentExpressionOrHigher);
return (force || isExpression(currentToken())) ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
}
function parseElementAccessArgumentExpression(openBracketToken: ISyntaxToken) {
@@ -3153,20 +3112,7 @@ module TypeScript.Parser {
parseElementAccessArgumentExpression(openBracketToken), eatToken(SyntaxKind.CloseBracketToken));
}
function tryParsePrimaryExpression(_currentToken: ISyntaxToken, force: boolean): IPrimaryExpressionSyntax {
// Have to check for 'async function' first as 'async' is an identifier and will be
// consumed immediately below this.
if (_currentToken.kind === SyntaxKind.AsyncKeyword) {
var token1 = peekToken(1);
if (!token1.hasLeadingNewLine() && token1.kind === SyntaxKind.FunctionKeyword) {
return parseFunctionExpression();
}
}
if (isIdentifier(_currentToken)) {
return eatIdentifierToken();
}
function parsePrimaryExpression(_currentToken: ISyntaxToken): IPrimaryExpressionSyntax {
var currentTokenKind = _currentToken.kind;
switch (currentTokenKind) {
case SyntaxKind.ThisKeyword:
@@ -3195,13 +3141,16 @@ module TypeScript.Parser {
// If we see a standalone / or /= and we're expecting an expression, then reparse
// it as a regular expression.
return reparseDivideAsRegularExpression();
case SyntaxKind.AsyncKeyword:
var token1 = peekToken(1);
if (!token1.hasLeadingNewLine() && token1.kind === SyntaxKind.FunctionKeyword) {
return parseFunctionExpression();
}
break;
}
if (!force) {
return undefined;
}
// Nothing else worked, report an error and produce a missing token.
// Nothing else worked. try to eat an identifier. If we can't, we'll report an
// appropriate error.
return eatIdentifierToken(DiagnosticCode.Expression_expected);
}
@@ -3228,15 +3177,15 @@ module TypeScript.Parser {
}
function parseTypeOfExpression(typeOfKeyword: ISyntaxToken): TypeOfExpressionSyntax {
return new TypeOfExpressionSyntax(contextFlags, consumeToken(typeOfKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
return new TypeOfExpressionSyntax(contextFlags, consumeToken(typeOfKeyword), parseUnaryExpressionOrHigher(currentToken()));
}
function parseDeleteExpression(deleteKeyword: ISyntaxToken): DeleteExpressionSyntax {
return new DeleteExpressionSyntax(contextFlags, consumeToken(deleteKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
return new DeleteExpressionSyntax(contextFlags, consumeToken(deleteKeyword), parseUnaryExpressionOrHigher(currentToken()));
}
function parseVoidExpression(voidKeyword: ISyntaxToken): VoidExpressionSyntax {
return new VoidExpressionSyntax(contextFlags, consumeToken(voidKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
return new VoidExpressionSyntax(contextFlags, consumeToken(voidKeyword), parseUnaryExpressionOrHigher(currentToken()));
}
function parseFunctionExpression(): FunctionExpressionSyntax {
@@ -3282,7 +3231,9 @@ module TypeScript.Parser {
// this decision.
return new ObjectCreationExpressionSyntax(contextFlags,
consumeToken(newKeyword), tryParseMemberExpressionOrHigher(currentToken(), /*force:*/ true), tryParseArgumentList());
consumeToken(newKeyword),
parseMemberExpressionOrHigher(currentToken()),
tryParseArgumentList());
}
function parseTemplateExpression(startToken: ISyntaxToken): IPrimaryExpressionSyntax {
@@ -3325,9 +3276,12 @@ module TypeScript.Parser {
return new TemplateClauseSyntax(contextFlags, expression, token);
}
function parseCastExpression(lessThanToken: ISyntaxToken): CastExpressionSyntax {
return new CastExpressionSyntax(contextFlags,
consumeToken(lessThanToken), parseType(), eatToken(SyntaxKind.GreaterThanToken), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
function parseTypeAssertionExpression(lessThanToken: ISyntaxToken): TypeAssertionExpressionSyntax {
return new TypeAssertionExpressionSyntax(contextFlags,
consumeToken(lessThanToken),
parseType(),
eatToken(SyntaxKind.GreaterThanToken),
parseUnaryExpressionOrHigher(currentToken()));
}
function parseParenthesizedExpression(openParenToken: ISyntaxToken): ParenthesizedExpressionSyntax {
@@ -4044,7 +3998,7 @@ module TypeScript.Parser {
// We do not want the > to be consumed as part of the "" expression. By starting
// at 'unary' expression and not 'binary' expression, we ensure that we don't accidently
// consume the >.
return tryParseUnaryExpressionOrHigher(_currentToken, /*force:*/ true);
return parseUnaryExpressionOrHigher(_currentToken);
}
return eatIdentifierToken(DiagnosticCode.Type_expected);
src/services/syntax/prettyPrinter.ts
+1 -1
View File
@@ -910,7 +910,7 @@ module TypeScript.PrettyPrinter {
this.appendNode(node.equalsValueClause);
}
public visitCastExpression(node: CastExpressionSyntax): void {
public visitTypeAssertionExpression(node: TypeAssertionExpressionSyntax): void {
this.appendToken(node.lessThanToken);
visitNodeOrToken(this, node.type);
this.appendToken(node.greaterThanToken);
src/services/syntax/syntaxElement.ts
-13
View File
@@ -371,19 +371,6 @@ module TypeScript {
return fullStart(element) + fullWidth(element);
}
export function existsNewLineBetweenTokens(token1: ISyntaxToken, token2: ISyntaxToken, text: ISimpleText) {
if (token1 === token2) {
return false;
}
if (!token1 || !token2) {
return true;
}
var lineMap = text.lineMap();
return lineMap.getLineNumberFromPosition(fullEnd(token1)) !== lineMap.getLineNumberFromPosition(start(token2, text));
}
export interface ISyntaxElement {
kind: SyntaxKind;
parent: ISyntaxElement;
src/services/syntax/syntaxGenerator.ts
+1 -1
View File
@@ -880,7 +880,7 @@ var definitions:ITypeDefinition[] = [
]
},
<any>{
name: 'CastExpressionSyntax',
name: 'TypeAssertionExpressionSyntax',
baseType: 'ISyntaxNode',
interfaces: ['IUnaryExpressionSyntax'],
children: [
src/services/syntax/syntaxInterfaces.generated.ts
+2 -2
View File
@@ -483,13 +483,13 @@ module TypeScript {
}
export interface SimpleArrowFunctionExpressionConstructor { new (data: number, asyncKeyword: ISyntaxToken, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, body: BlockSyntax | IExpressionSyntax): SimpleArrowFunctionExpressionSyntax }
export interface CastExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax {
export interface TypeAssertionExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax {
lessThanToken: ISyntaxToken;
type: ITypeSyntax;
greaterThanToken: ISyntaxToken;
expression: IUnaryExpressionSyntax;
}
export interface CastExpressionConstructor { new (data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax): CastExpressionSyntax }
export interface TypeAssertionExpressionConstructor { new (data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax): TypeAssertionExpressionSyntax }
export interface ElementAccessExpressionSyntax extends ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax {
expression: ILeftHandSideExpressionSyntax;
src/services/syntax/syntaxKind.ts
+1 -1
View File
@@ -230,7 +230,7 @@ module TypeScript {
ParenthesizedExpression,
ParenthesizedArrowFunctionExpression,
SimpleArrowFunctionExpression,
CastExpression,
TypeAssertionExpression,
ElementAccessExpression,
FunctionExpression,
OmittedExpression,
src/services/syntax/syntaxNodes.concrete.generated.ts
+4 -4
View File
@@ -1322,7 +1322,7 @@ module TypeScript {
}
}
export var CastExpressionSyntax: CastExpressionConstructor = <any>function(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax) {
export var TypeAssertionExpressionSyntax: TypeAssertionExpressionConstructor = <any>function(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax) {
if (data) { this.__data = data; }
this.lessThanToken = lessThanToken,
this.type = type,
@@ -1333,9 +1333,9 @@ module TypeScript {
greaterThanToken.parent = this,
expression.parent = this;
};
CastExpressionSyntax.prototype.kind = SyntaxKind.CastExpression;
CastExpressionSyntax.prototype.childCount = 4;
CastExpressionSyntax.prototype.childAt = function(index: number): ISyntaxElement {
TypeAssertionExpressionSyntax.prototype.kind = SyntaxKind.TypeAssertionExpression;
TypeAssertionExpressionSyntax.prototype.childCount = 4;
TypeAssertionExpressionSyntax.prototype.childAt = function(index: number): ISyntaxElement {
switch (index) {
case 0: return this.lessThanToken;
case 1: return this.type;
src/services/syntax/syntaxUtilities.ts
+1 -1
View File
@@ -186,7 +186,7 @@ module TypeScript {
switch (parent.kind) {
case SyntaxKind.TypeArgumentList:
case SyntaxKind.TypeParameterList:
case SyntaxKind.CastExpression:
case SyntaxKind.TypeAssertionExpression:
return true;
}
}
src/services/syntax/syntaxVisitor.generated.ts
+2 -2
View File
@@ -65,7 +65,7 @@ module TypeScript {
case SyntaxKind.ParenthesizedExpression: return visitor.visitParenthesizedExpression(<ParenthesizedExpressionSyntax>element);
case SyntaxKind.ParenthesizedArrowFunctionExpression: return visitor.visitParenthesizedArrowFunctionExpression(<ParenthesizedArrowFunctionExpressionSyntax>element);
case SyntaxKind.SimpleArrowFunctionExpression: return visitor.visitSimpleArrowFunctionExpression(<SimpleArrowFunctionExpressionSyntax>element);
case SyntaxKind.CastExpression: return visitor.visitCastExpression(<CastExpressionSyntax>element);
case SyntaxKind.TypeAssertionExpression: return visitor.visitTypeAssertionExpression(<TypeAssertionExpressionSyntax>element);
case SyntaxKind.ElementAccessExpression: return visitor.visitElementAccessExpression(<ElementAccessExpressionSyntax>element);
case SyntaxKind.FunctionExpression: return visitor.visitFunctionExpression(<FunctionExpressionSyntax>element);
case SyntaxKind.OmittedExpression: return visitor.visitOmittedExpression(<OmittedExpressionSyntax>element);
@@ -165,7 +165,7 @@ module TypeScript {
visitParenthesizedExpression(node: ParenthesizedExpressionSyntax): any;
visitParenthesizedArrowFunctionExpression(node: ParenthesizedArrowFunctionExpressionSyntax): any;
visitSimpleArrowFunctionExpression(node: SimpleArrowFunctionExpressionSyntax): any;
visitCastExpression(node: CastExpressionSyntax): any;
visitTypeAssertionExpression(node: TypeAssertionExpressionSyntax): any;
visitElementAccessExpression(node: ElementAccessExpressionSyntax): any;
visitFunctionExpression(node: FunctionExpressionSyntax): any;
visitOmittedExpression(node: OmittedExpressionSyntax): any;
src/services/syntax/syntaxWalker.generated.ts
+1 -1
View File
@@ -439,7 +439,7 @@ module TypeScript {
visitNodeOrToken(this, node.body);
}
public visitCastExpression(node: CastExpressionSyntax): void {
public visitTypeAssertionExpression(node: TypeAssertionExpressionSyntax): void {
this.visitToken(node.lessThanToken);
visitNodeOrToken(this, node.type);
this.visitToken(node.greaterThanToken);