Skip to content

Commit ab7d65e

Browse files
sheetalkamatsheetalkamat
committed
Merge branch 'master' into usePrependToSkipBuild
2 parents 3a28fb0 + 8e5dcfb commit ab7d65e

120 files changed

Lines changed: 3959 additions & 2021 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎src/compiler/binder.ts‎

Lines changed: 41 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1120,11 +1120,15 @@ namespace ts {
11201120
// We add the nodes within the `try` block to the `finally`'s antecedents if there's no catch block
11211121
// (If there is a `catch` block, it will have all these antecedents instead, and the `finally` will
11221122
// have the end of the `try` block and the end of the `catch` block)
1123+
let preFinallyPrior = preTryFlow;
11231124
if (!node.catchClause) {
11241125
if (tryPriors.length) {
1126+
const preFinallyFlow = createBranchLabel();
1127+
addAntecedent(preFinallyFlow, preTryFlow);
11251128
for (const p of tryPriors) {
1126-
addAntecedent(preFinallyLabel, p);
1129+
addAntecedent(preFinallyFlow, p);
11271130
}
1131+
preFinallyPrior = finishFlowLabel(preFinallyFlow);
11281132
}
11291133
}
11301134

@@ -1156,7 +1160,7 @@ namespace ts {
11561160
//
11571161
// extra edges that we inject allows to control this behavior
11581162
// if when walking the flow we step on post-finally edge - we can mark matching pre-finally edge as locked so it will be skipped.
1159-
const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preTryFlow, lock: {} };
1163+
const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preFinallyPrior, lock: {} };
11601164
addAntecedent(preFinallyLabel, preFinallyFlow);
11611165

11621166
currentFlow = finishFlowLabel(preFinallyLabel);
@@ -3137,8 +3141,8 @@ namespace ts {
31373141

31383142
if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ObjectLiteralExpression) {
31393143
// Destructuring object assignments with are ES2015 syntax
3140-
// and possibly ESNext if they contain rest
3141-
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment;
3144+
// and possibly ES2018 if they contain rest
3145+
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment;
31423146
}
31433147
else if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ArrayLiteralExpression) {
31443148
// Destructuring assignments are ES2015 syntax.
@@ -3174,9 +3178,9 @@ namespace ts {
31743178
transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsTypeScriptClassSyntax;
31753179
}
31763180

3177-
// parameters with object rest destructuring are ES Next syntax
3181+
// parameters with object rest destructuring are ES2018 syntax
31783182
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3179-
transformFlags |= TransformFlags.AssertESNext;
3183+
transformFlags |= TransformFlags.AssertES2018;
31803184
}
31813185

31823186
// If a parameter has an initializer, a binding pattern or a dotDotDot token, then
@@ -3326,9 +3330,9 @@ namespace ts {
33263330
transformFlags |= TransformFlags.AssertTypeScript;
33273331
}
33283332

3329-
// function declarations with object rest destructuring are ES Next syntax
3333+
// function declarations with object rest destructuring are ES2018 syntax
33303334
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3331-
transformFlags |= TransformFlags.AssertESNext;
3335+
transformFlags |= TransformFlags.AssertES2018;
33323336
}
33333337

33343338
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3350,14 +3354,14 @@ namespace ts {
33503354
transformFlags |= TransformFlags.AssertTypeScript;
33513355
}
33523356

3353-
// function declarations with object rest destructuring are ES Next syntax
3357+
// function declarations with object rest destructuring are ES2018 syntax
33543358
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3355-
transformFlags |= TransformFlags.AssertESNext;
3359+
transformFlags |= TransformFlags.AssertES2018;
33563360
}
33573361

33583362
// An async method declaration is ES2017 syntax.
33593363
if (hasModifier(node, ModifierFlags.Async)) {
3360-
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
3364+
transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017;
33613365
}
33623366

33633367
if (node.asteriskToken) {
@@ -3381,9 +3385,9 @@ namespace ts {
33813385
transformFlags |= TransformFlags.AssertTypeScript;
33823386
}
33833387

3384-
// function declarations with object rest destructuring are ES Next syntax
3388+
// function declarations with object rest destructuring are ES2018 syntax
33853389
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3386-
transformFlags |= TransformFlags.AssertESNext;
3390+
transformFlags |= TransformFlags.AssertES2018;
33873391
}
33883392

33893393
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3427,12 +3431,12 @@ namespace ts {
34273431

34283432
// An async function declaration is ES2017 syntax.
34293433
if (modifierFlags & ModifierFlags.Async) {
3430-
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
3434+
transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017;
34313435
}
34323436

3433-
// function declarations with object rest destructuring are ES Next syntax
3437+
// function declarations with object rest destructuring are ES2018 syntax
34343438
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3435-
transformFlags |= TransformFlags.AssertESNext;
3439+
transformFlags |= TransformFlags.AssertES2018;
34363440
}
34373441

34383442
// If a FunctionDeclaration's subtree has marked the container as needing to capture the
@@ -3469,12 +3473,12 @@ namespace ts {
34693473

34703474
// An async function expression is ES2017 syntax.
34713475
if (hasModifier(node, ModifierFlags.Async)) {
3472-
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
3476+
transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017;
34733477
}
34743478

3475-
// function expressions with object rest destructuring are ES Next syntax
3479+
// function expressions with object rest destructuring are ES2018 syntax
34763480
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3477-
transformFlags |= TransformFlags.AssertESNext;
3481+
transformFlags |= TransformFlags.AssertES2018;
34783482
}
34793483

34803484

@@ -3513,9 +3517,9 @@ namespace ts {
35133517
transformFlags |= TransformFlags.AssertES2017;
35143518
}
35153519

3516-
// arrow functions with object rest destructuring are ES Next syntax
3520+
// arrow functions with object rest destructuring are ES2018 syntax
35173521
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3518-
transformFlags |= TransformFlags.AssertESNext;
3522+
transformFlags |= TransformFlags.AssertES2018;
35193523
}
35203524

35213525
// If an ArrowFunction contains a lexical this, its container must capture the lexical this.
@@ -3535,8 +3539,8 @@ namespace ts {
35353539
if (transformFlags & TransformFlags.Super) {
35363540
transformFlags ^= TransformFlags.Super;
35373541
// super inside of an async function requires hoisting the super access (ES2017).
3538-
// same for super inside of an async generator, which is ESNext.
3539-
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext;
3542+
// same for super inside of an async generator, which is ES2018.
3543+
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018;
35403544
}
35413545

35423546
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3553,8 +3557,8 @@ namespace ts {
35533557
if (expressionFlags & TransformFlags.Super) {
35543558
transformFlags &= ~TransformFlags.Super;
35553559
// super inside of an async function requires hoisting the super access (ES2017).
3556-
// same for super inside of an async generator, which is ESNext.
3557-
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext;
3560+
// same for super inside of an async generator, which is ES2018.
3561+
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018;
35583562
}
35593563

35603564
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3565,9 +3569,9 @@ namespace ts {
35653569
let transformFlags = subtreeFlags;
35663570
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
35673571

3568-
// A VariableDeclaration containing ObjectRest is ESNext syntax
3572+
// A VariableDeclaration containing ObjectRest is ES2018 syntax
35693573
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
3570-
transformFlags |= TransformFlags.AssertESNext;
3574+
transformFlags |= TransformFlags.AssertES2018;
35713575
}
35723576

35733577
// Type annotations are TypeScript syntax.
@@ -3674,8 +3678,8 @@ namespace ts {
36743678
switch (kind) {
36753679
case SyntaxKind.AsyncKeyword:
36763680
case SyntaxKind.AwaitExpression:
3677-
// async/await is ES2017 syntax, but may be ESNext syntax (for async generators)
3678-
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2017;
3681+
// async/await is ES2017 syntax, but may be ES2018 syntax (for async generators)
3682+
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2017;
36793683
break;
36803684

36813685
case SyntaxKind.TypeAssertionExpression:
@@ -3747,15 +3751,15 @@ namespace ts {
37473751
case SyntaxKind.ForOfStatement:
37483752
// This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of).
37493753
if ((<ForOfStatement>node).awaitModifier) {
3750-
transformFlags |= TransformFlags.AssertESNext;
3754+
transformFlags |= TransformFlags.AssertES2018;
37513755
}
37523756
transformFlags |= TransformFlags.AssertES2015;
37533757
break;
37543758

37553759
case SyntaxKind.YieldExpression:
37563760
// This node is either ES2015 syntax (in a generator) or ES2017 syntax (in an async
37573761
// generator).
3758-
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
3762+
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
37593763
break;
37603764

37613765
case SyntaxKind.AnyKeyword:
@@ -3824,7 +3828,7 @@ namespace ts {
38243828
break;
38253829

38263830
case SyntaxKind.SpreadAssignment:
3827-
transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread;
3831+
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread;
38283832
break;
38293833

38303834
case SyntaxKind.SuperKeyword:
@@ -3841,7 +3845,7 @@ namespace ts {
38413845
case SyntaxKind.ObjectBindingPattern:
38423846
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
38433847
if (subtreeFlags & TransformFlags.ContainsRestOrSpread) {
3844-
transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread;
3848+
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread;
38453849
}
38463850
excludeFlags = TransformFlags.BindingPatternExcludes;
38473851
break;
@@ -3879,8 +3883,8 @@ namespace ts {
38793883

38803884
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
38813885
// If an ObjectLiteralExpression contains a spread element, then it
3882-
// is an ES next node.
3883-
transformFlags |= TransformFlags.AssertESNext;
3886+
// is an ES2018 node.
3887+
transformFlags |= TransformFlags.AssertES2018;
38843888
}
38853889

38863890
break;
@@ -3915,8 +3919,8 @@ namespace ts {
39153919
break;
39163920

39173921
case SyntaxKind.ReturnStatement:
3918-
// Return statements may require an `await` in ESNext.
3919-
transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertESNext;
3922+
// Return statements may require an `await` in ES2018.
3923+
transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertES2018;
39203924
break;
39213925

39223926
case SyntaxKind.ContinueStatement:

0 commit comments

Comments
 (0)