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

Merge pull request #460 from Microsoft/noArrowLookahead

Browse Source 
Removed lookahead for simple arrow function expressions.
This commit is contained in:
Anders Hejlsberg 2014-08-15 12:54:18 -07:00
commit eea8409e4f
1 changed files with 20 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/compiler/parser.ts
View File

@ -1554,11 +1554,11 @@ module ts {
// Note: for ease of implementation we treat productions '2' and '3' as the same thing.
// (i.e. they're both BinaryExpressions with an assignment operator in it).
// First, check if we have production '4' (an arrow function). Note that if we do, we
// must *not* recurse for productsion 1, 2 or 3. An ArrowFunction is not a
// LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done
// First, check if we have an arrow function (production '4') that starts with a parenthesized
// parameter list. If we do, we must *not* recurse for productsion 1, 2 or 3. An ArrowFunction is
// not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done
// with AssignmentExpression if we see one.
var arrowExpression = tryParseArrowFunctionExpression();
var arrowExpression = tryParseParenthesizedArrowFunctionExpression();
if (arrowExpression) {
return arrowExpression;
}
@ -1567,6 +1567,13 @@ module ts {
// including a conditional expression.
var expr = parseConditionalExpression(noIn);
// To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized
// parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
// identifier and the current token is an arrow.
if (expr.kind === SyntaxKind.Identifier && token === SyntaxKind.EqualsGreaterThanToken) {
return parseSimpleArrowFunctionExpression(<Identifier>expr);
}
// Now see if we might be in cases '2' or '3'.
// If the expression was a LHS expression, and we have an assignment operator, then
// we're in '2' or '3'. Consume the assignment and return.
@ -1613,39 +1620,7 @@ module ts {
return false;
}
function tryParseArrowFunctionExpression(): Expression {
return isSimpleArrowFunctionExpression()
? parseSimpleArrowFunctionExpression()
: tryParseParenthesizedArrowFunctionExpression();
}
function isSimpleArrowFunctionExpression(): boolean {
if (token === SyntaxKind.EqualsGreaterThanToken) {
// ERROR RECOVERY TWEAK:
// If we see a standalone => try to parse it as an arrow function expression as that's
// likely whatthe user intended to write.
return true;
}
if (token === SyntaxKind.Identifier) {
// if we see: a =>
// then this is clearly an arrow function expression.
return lookAhead(() => {
return nextToken() === SyntaxKind.EqualsGreaterThanToken;
});
}
// Definitely not a simple arrow function expression.
return false;
}
function parseSimpleArrowFunctionExpression(): Expression {
Debug.assert(token === SyntaxKind.Identifier || token === SyntaxKind.EqualsGreaterThanToken);
// Get the identifier for the simple arrow. If one isn't there then we'll report a useful
// message that it is missing.
var identifier = parseIdentifier();
function parseSimpleArrowFunctionExpression(identifier: Identifier): Expression {
Debug.assert(token === SyntaxKind.EqualsGreaterThanToken, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
parseExpected(SyntaxKind.EqualsGreaterThanToken);
@ -1664,8 +1639,6 @@ module ts {
}
function tryParseParenthesizedArrowFunctionExpression(): Expression {
var pos = getNodePos();
// Indicates whether we are certain that we should parse an arrow expression.
var triState = isParenthesizedArrowFunctionExpression();
@ -1673,6 +1646,8 @@ module ts {
return undefined;
}
var pos = getNodePos();
if (triState === Tristate.True) {
var sig = parseSignature(SyntaxKind.CallSignature, SyntaxKind.ColonToken);
@ -1765,7 +1740,12 @@ module ts {
}
});
}
if (token === SyntaxKind.EqualsGreaterThanToken) {
// ERROR RECOVERY TWEAK:
// If we see a standalone => try to parse it as an arrow function expression as that's
// likely whatthe user intended to write.
return Tristate.True;
}
// Definitely not a parenthesized arrow function.
return Tristate.False;
}