Skip to content

Commit b692ea9

Browse files
CyrusNajmabadiCyrusNajmabadi
committed
Remove TryBlock and FinallyBlock.
They break the rule that syntactically identical constructs use the same syntax kind. This prevents node reuse in incremental parsing.
1 parent 12f8bfb commit b692ea9

20 files changed

Lines changed: 117 additions & 127 deletions

‎src/compiler/binder.ts‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -493,9 +493,7 @@ module ts {
493493
break;
494494
}
495495
case SyntaxKind.Block:
496-
case SyntaxKind.TryBlock:
497496
case SyntaxKind.CatchClause:
498-
case SyntaxKind.FinallyBlock:
499497
case SyntaxKind.ForStatement:
500498
case SyntaxKind.ForInStatement:
501499
case SyntaxKind.SwitchStatement:

‎src/compiler/checker.ts‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4569,9 +4569,7 @@ module ts {
45694569
case SyntaxKind.LabeledStatement:
45704570
case SyntaxKind.ThrowStatement:
45714571
case SyntaxKind.TryStatement:
4572-
case SyntaxKind.TryBlock:
45734572
case SyntaxKind.CatchClause:
4574-
case SyntaxKind.FinallyBlock:
45754573
return forEachChild(node, isAssignedIn);
45764574
}
45774575
return false;
@@ -8894,9 +8892,7 @@ module ts {
88948892
case SyntaxKind.LabeledStatement:
88958893
case SyntaxKind.ThrowStatement:
88968894
case SyntaxKind.TryStatement:
8897-
case SyntaxKind.TryBlock:
88988895
case SyntaxKind.CatchClause:
8899-
case SyntaxKind.FinallyBlock:
89008896
case SyntaxKind.VariableDeclaration:
89018897
case SyntaxKind.ClassDeclaration:
89028898
case SyntaxKind.EnumDeclaration:

‎src/compiler/emitter.ts‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3907,8 +3907,6 @@ module ts {
39073907
case SyntaxKind.OmittedExpression:
39083908
return;
39093909
case SyntaxKind.Block:
3910-
case SyntaxKind.TryBlock:
3911-
case SyntaxKind.FinallyBlock:
39123910
case SyntaxKind.ModuleBlock:
39133911
return emitBlock(<Block>node);
39143912
case SyntaxKind.VariableStatement:

‎src/compiler/parser.ts‎

Lines changed: 14 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -361,8 +361,6 @@ module ts {
361361
child((<ConditionalExpression>node).whenTrue) ||
362362
child((<ConditionalExpression>node).whenFalse);
363363
case SyntaxKind.Block:
364-
case SyntaxKind.TryBlock:
365-
case SyntaxKind.FinallyBlock:
366364
case SyntaxKind.ModuleBlock:
367365
return children((<Block>node).statements);
368366
case SyntaxKind.SourceFile:
@@ -492,9 +490,7 @@ module ts {
492490
case SyntaxKind.DefaultClause:
493491
case SyntaxKind.LabeledStatement:
494492
case SyntaxKind.TryStatement:
495-
case SyntaxKind.TryBlock:
496493
case SyntaxKind.CatchClause:
497-
case SyntaxKind.FinallyBlock:
498494
return forEachChild(node, traverse);
499495
}
500496
}
@@ -3529,8 +3525,8 @@ module ts {
35293525
}
35303526

35313527
// STATEMENTS
3532-
function parseBlock(kind: SyntaxKind, ignoreMissingOpenBrace: boolean, checkForStrictMode: boolean, diagnosticMessage?: DiagnosticMessage): Block {
3533-
var node = <Block>createNode(kind);
3528+
function parseBlock(ignoreMissingOpenBrace: boolean, checkForStrictMode: boolean, diagnosticMessage?: DiagnosticMessage): Block {
3529+
var node = <Block>createNode(SyntaxKind.Block);
35343530
if (parseExpected(SyntaxKind.OpenBraceToken, diagnosticMessage) || ignoreMissingOpenBrace) {
35353531
node.statements = parseList(ParsingContext.BlockStatements, checkForStrictMode, parseStatement);
35363532
parseExpected(SyntaxKind.CloseBraceToken);
@@ -3545,7 +3541,7 @@ module ts {
35453541
var savedYieldContext = inYieldContext();
35463542
setYieldContext(allowYield);
35473543

3548-
var block = parseBlock(SyntaxKind.Block, ignoreMissingOpenBrace, /*checkForStrictMode*/ true, diagnosticMessage);
3544+
var block = parseBlock(ignoreMissingOpenBrace, /*checkForStrictMode*/ true, diagnosticMessage);
35493545

35503546
setYieldContext(savedYieldContext);
35513547

@@ -3739,25 +3735,19 @@ module ts {
37393735
// TODO: Review for error recovery
37403736
function parseTryStatement(): TryStatement {
37413737
var node = <TryStatement>createNode(SyntaxKind.TryStatement);
3742-
node.tryBlock = parseTokenAndBlock(SyntaxKind.TryKeyword);
3738+
3739+
parseExpected(SyntaxKind.TryKeyword);
3740+
node.tryBlock = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode*/ false);
37433741
node.catchClause = token === SyntaxKind.CatchKeyword ? parseCatchClause() : undefined;
37443742

37453743
// If we don't have a catch clause, then we must have a finally clause. Try to parse
37463744
// one out no matter what.
3747-
node.finallyBlock = !node.catchClause || token === SyntaxKind.FinallyKeyword
3748-
? parseTokenAndBlock(SyntaxKind.FinallyKeyword)
3749-
: undefined;
3750-
return finishNode(node);
3751-
}
3745+
if (!node.catchClause || token === SyntaxKind.FinallyKeyword) {
3746+
parseExpected(SyntaxKind.FinallyKeyword);
3747+
node.finallyBlock = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode*/ false);
3748+
}
37523749

3753-
function parseTokenAndBlock(token: SyntaxKind): Block {
3754-
var pos = getNodePos();
3755-
parseExpected(token);
3756-
var result = parseBlock(
3757-
token === SyntaxKind.TryKeyword ? SyntaxKind.TryBlock : SyntaxKind.FinallyBlock,
3758-
/* ignoreMissingOpenBrace */ false, /*checkForStrictMode*/ false);
3759-
result.pos = pos;
3760-
return result;
3750+
return finishNode(node);
37613751
}
37623752

37633753
function parseCatchClause(): CatchClause {
@@ -3767,7 +3757,7 @@ module ts {
37673757
result.name = parseIdentifier();
37683758
result.type = parseTypeAnnotation();
37693759
parseExpected(SyntaxKind.CloseParenToken);
3770-
result.block = parseBlock(SyntaxKind.Block, /* ignoreMissingOpenBrace */ false, /*checkForStrictMode*/ false);
3760+
result.block = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode:*/ false);
37713761
return finishNode(result);
37723762
}
37733763

@@ -3876,7 +3866,7 @@ module ts {
38763866
function parseStatement(): Statement {
38773867
switch (token) {
38783868
case SyntaxKind.OpenBraceToken:
3879-
return parseBlock(SyntaxKind.Block, /* ignoreMissingOpenBrace */ false, /*checkForStrictMode*/ false);
3869+
return parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode:*/ false);
38803870
case SyntaxKind.VarKeyword:
38813871
case SyntaxKind.ConstKeyword:
38823872
// const here should always be parsed as const declaration because of check in 'isStatement'
@@ -4715,7 +4705,7 @@ module ts {
47154705
inFunctionBlock = true;
47164706
}
47174707
var savedInBlock = inBlock;
4718-
if (node.kind === SyntaxKind.Block || node.kind === SyntaxKind.TryBlock || node.kind === SyntaxKind.FinallyBlock) {
4708+
if (node.kind === SyntaxKind.Block) {
47194709
inBlock = true;
47204710
}
47214711
var savedInObjectLiteralExpression = inObjectLiteralExpression;

‎src/compiler/types.ts‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -213,8 +213,6 @@ module ts {
213213
LabeledStatement,
214214
ThrowStatement,
215215
TryStatement,
216-
TryBlock,
217-
FinallyBlock,
218216
DebuggerStatement,
219217
VariableDeclaration,
220218
FunctionDeclaration,

‎src/services/breakpoints.ts‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -108,8 +108,6 @@ module ts.BreakpointResolver {
108108
return spanInFunctionBlock(<Block>node);
109109
}
110110
// Fall through
111-
case SyntaxKind.TryBlock:
112-
case SyntaxKind.FinallyBlock:
113111
case SyntaxKind.ModuleBlock:
114112
return spanInBlock(<Block>node);
115113

@@ -429,9 +427,7 @@ module ts.BreakpointResolver {
429427
}
430428
// fall through.
431429

432-
case SyntaxKind.TryBlock:
433430
case SyntaxKind.CatchClause:
434-
case SyntaxKind.FinallyBlock:
435431
return spanInNode((<Block>node.parent).statements[(<Block>node.parent).statements.length - 1]);;
436432

437433
case SyntaxKind.SwitchStatement:

‎src/services/formatting.ts‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -154,8 +154,6 @@ module ts.formatting {
154154
return body && body.kind === SyntaxKind.Block && rangeContainsRange((<Block>body).statements, node);
155155
case SyntaxKind.SourceFile:
156156
case SyntaxKind.Block:
157-
case SyntaxKind.TryBlock:
158-
case SyntaxKind.FinallyBlock:
159157
case SyntaxKind.ModuleBlock:
160158
return rangeContainsRange((<Block>parent).statements, node);
161159
case SyntaxKind.CatchClause:
@@ -932,9 +930,6 @@ module ts.formatting {
932930
function isSomeBlock(kind: SyntaxKind): boolean {
933931
switch (kind) {
934932
case SyntaxKind.Block:
935-
case SyntaxKind.Block:
936-
case SyntaxKind.TryBlock:
937-
case SyntaxKind.FinallyBlock:
938933
case SyntaxKind.ModuleBlock:
939934
return true;
940935
}

‎src/services/formatting/rules.ts‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -525,8 +525,6 @@ module ts.formatting {
525525
case SyntaxKind.Block:
526526
case SyntaxKind.SwitchStatement:
527527
case SyntaxKind.ObjectLiteralExpression:
528-
case SyntaxKind.TryBlock:
529-
case SyntaxKind.FinallyBlock:
530528
case SyntaxKind.ModuleBlock:
531529
return true;
532530
}
@@ -580,9 +578,7 @@ module ts.formatting {
580578
case SyntaxKind.ModuleDeclaration:
581579
case SyntaxKind.EnumDeclaration:
582580
case SyntaxKind.Block:
583-
case SyntaxKind.TryBlock:
584581
case SyntaxKind.CatchClause:
585-
case SyntaxKind.FinallyBlock:
586582
case SyntaxKind.ModuleBlock:
587583
case SyntaxKind.SwitchStatement:
588584
return true;
@@ -603,7 +599,6 @@ module ts.formatting {
603599
// TODO
604600
// case SyntaxKind.ElseClause:
605601
case SyntaxKind.CatchClause:
606-
case SyntaxKind.FinallyBlock:
607602
return true;
608603

609604
default:

‎src/services/outliningElementsCollector.ts‎

Lines changed: 30 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -84,25 +84,43 @@ module ts {
8484
parent.kind === SyntaxKind.CatchClause) {
8585

8686
addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n));
87+
break;
8788
}
88-
else {
89-
// Block was a standalone block. In this case we want to only collapse
90-
// the span of the block, independent of any parent span.
91-
var span = TextSpan.fromBounds(n.getStart(), n.end);
92-
elements.push({
93-
textSpan: span,
94-
hintSpan: span,
95-
bannerText: collapseText,
96-
autoCollapse: autoCollapse(n)
97-
});
89+
90+
if (parent.kind === SyntaxKind.TryStatement) {
91+
// Could be the try-block, or the finally-block.
92+
var tryStatement = <TryStatement>parent;
93+
if (tryStatement.tryBlock === n) {
94+
addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n));
95+
break;
96+
}
97+
else if (tryStatement.finallyBlock === n) {
98+
var children = tryStatement.getChildren();
99+
for (var i = 0, m = children.length; i < m; i++) {
100+
if (children[i].kind === SyntaxKind.FinallyKeyword) {
101+
addOutliningSpan(children[i], openBrace, closeBrace, autoCollapse(n));
102+
break;
103+
}
104+
}
105+
}
106+
107+
// fall through.
98108
}
109+
110+
// Block was a standalone block. In this case we want to only collapse
111+
// the span of the block, independent of any parent span.
112+
var span = TextSpan.fromBounds(n.getStart(), n.end);
113+
elements.push({
114+
textSpan: span,
115+
hintSpan: span,
116+
bannerText: collapseText,
117+
autoCollapse: autoCollapse(n)
118+
});
99119
break;
100120
}
101121
// Fallthrough.
102122

103123
case SyntaxKind.ModuleBlock:
104-
case SyntaxKind.TryBlock:
105-
case SyntaxKind.FinallyBlock:
106124
var openBrace = findChildOfKind(n, SyntaxKind.OpenBraceToken, sourceFile);
107125
var closeBrace = findChildOfKind(n, SyntaxKind.CloseBraceToken, sourceFile);
108126
addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n));

‎src/services/services.ts‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3418,13 +3418,17 @@ module ts {
34183418
return getThrowOccurrences(<ThrowStatement>node.parent);
34193419
}
34203420
break;
3421-
case SyntaxKind.TryKeyword:
34223421
case SyntaxKind.CatchKeyword:
3423-
case SyntaxKind.FinallyKeyword:
34243422
if (hasKind(parent(parent(node)), SyntaxKind.TryStatement)) {
34253423
return getTryCatchFinallyOccurrences(<TryStatement>node.parent.parent);
34263424
}
34273425
break;
3426+
case SyntaxKind.TryKeyword:
3427+
case SyntaxKind.FinallyKeyword:
3428+
if (hasKind(parent(node), SyntaxKind.TryStatement)) {
3429+
return getTryCatchFinallyOccurrences(<TryStatement>node.parent);
3430+
}
3431+
break;
34283432
case SyntaxKind.SwitchKeyword:
34293433
if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
34303434
return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent);
@@ -3658,7 +3662,12 @@ module ts {
36583662
}
36593663

36603664
if (tryStatement.finallyBlock) {
3661-
pushKeywordIf(keywords, tryStatement.finallyBlock.getFirstToken(), SyntaxKind.FinallyKeyword);
3665+
var children = tryStatement.getChildren();
3666+
for (var i = 0, n = children.length; i < n; i++) {
3667+
if (pushKeywordIf(keywords, children[i], SyntaxKind.FinallyKeyword)) {
3668+
break;
3669+
}
3670+
}
36623671
}
36633672

36643673
return map(keywords, getReferenceEntryFromNode);

0 commit comments

Comments
 (0)