Skip to content

Commit 64d2698

Browse files
ahejlsbergahejlsberg
committed
Merge branch 'master' into mappedTypes
# Conflicts: # src/compiler/checker.ts
2 parents aca1ab3 + c87bce1 commit 64d2698

166 files changed

Lines changed: 9844 additions & 1677 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.

‎Jakefile.js‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -71,6 +71,7 @@ var compilerSources = [
7171
"transformers/destructuring.ts",
7272
"transformers/ts.ts",
7373
"transformers/jsx.ts",
74+
"transformers/esnext.ts",
7475
"transformers/es2017.ts",
7576
"transformers/es2016.ts",
7677
"transformers/es2015.ts",
@@ -107,6 +108,7 @@ var servicesSources = [
107108
"transformers/destructuring.ts",
108109
"transformers/ts.ts",
109110
"transformers/jsx.ts",
111+
"transformers/esnext.ts",
110112
"transformers/es2017.ts",
111113
"transformers/es2016.ts",
112114
"transformers/es2015.ts",

‎src/compiler/binder.ts‎

Lines changed: 89 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1139,8 +1139,8 @@ namespace ts {
11391139
}
11401140
else if (node.kind === SyntaxKind.ArrayLiteralExpression) {
11411141
for (const e of (<ArrayLiteralExpression>node).elements) {
1142-
if (e.kind === SyntaxKind.SpreadElementExpression) {
1143-
bindAssignmentTargetFlow((<SpreadElementExpression>e).expression);
1142+
if (e.kind === SyntaxKind.SpreadElement) {
1143+
bindAssignmentTargetFlow((<SpreadElement>e).expression);
11441144
}
11451145
else {
11461146
bindDestructuringTargetFlow(e);
@@ -1155,6 +1155,9 @@ namespace ts {
11551155
else if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
11561156
bindAssignmentTargetFlow((<ShorthandPropertyAssignment>p).name);
11571157
}
1158+
else if (p.kind === SyntaxKind.SpreadAssignment) {
1159+
bindAssignmentTargetFlow((<SpreadAssignment>p).expression);
1160+
}
11581161
}
11591162
}
11601163
}
@@ -1918,6 +1921,9 @@ namespace ts {
19181921
return bindParameter(<ParameterDeclaration>node);
19191922
case SyntaxKind.VariableDeclaration:
19201923
case SyntaxKind.BindingElement:
1924+
if ((node as BindingElement).dotDotDotToken && node.parent.kind === SyntaxKind.ObjectBindingPattern) {
1925+
emitFlags |= NodeFlags.HasRestAttribute;
1926+
}
19211927
return bindVariableDeclarationOrBindingElement(<VariableDeclaration | BindingElement>node);
19221928
case SyntaxKind.PropertyDeclaration:
19231929
case SyntaxKind.PropertySignature:
@@ -1931,8 +1937,21 @@ namespace ts {
19311937
case SyntaxKind.EnumMember:
19321938
return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
19331939

1940+
case SyntaxKind.SpreadAssignment:
19341941
case SyntaxKind.JsxSpreadAttribute:
1935-
emitFlags |= NodeFlags.HasJsxSpreadAttributes;
1942+
let root = container;
1943+
let hasRest = false;
1944+
while (root.parent) {
1945+
if (root.kind === SyntaxKind.ObjectLiteralExpression &&
1946+
root.parent.kind === SyntaxKind.BinaryExpression &&
1947+
(root.parent as BinaryExpression).operatorToken.kind === SyntaxKind.EqualsToken &&
1948+
(root.parent as BinaryExpression).left === root) {
1949+
hasRest = true;
1950+
break;
1951+
}
1952+
root = root.parent;
1953+
}
1954+
emitFlags |= hasRest ? NodeFlags.HasRestAttribute : NodeFlags.HasSpreadAttribute;
19361955
return;
19371956

19381957
case SyntaxKind.CallSignature:
@@ -2498,9 +2517,9 @@ namespace ts {
24982517
transformFlags |= TransformFlags.AssertTypeScript;
24992518
}
25002519

2501-
if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression
2520+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression
25022521
|| isSuperOrSuperProperty(expression, expressionKind)) {
2503-
// If the this node contains a SpreadElementExpression, or is a super call, then it is an ES6
2522+
// If the this node contains a SpreadExpression, or is a super call, then it is an ES6
25042523
// node.
25052524
transformFlags |= TransformFlags.AssertES2015;
25062525
}
@@ -2529,7 +2548,7 @@ namespace ts {
25292548
if (node.typeArguments) {
25302549
transformFlags |= TransformFlags.AssertTypeScript;
25312550
}
2532-
if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
2551+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
25332552
// If the this node contains a SpreadElementExpression then it is an ES6
25342553
// node.
25352554
transformFlags |= TransformFlags.AssertES2015;
@@ -2544,10 +2563,13 @@ namespace ts {
25442563
const operatorTokenKind = node.operatorToken.kind;
25452564
const leftKind = node.left.kind;
25462565

2547-
if (operatorTokenKind === SyntaxKind.EqualsToken
2548-
&& (leftKind === SyntaxKind.ObjectLiteralExpression
2549-
|| leftKind === SyntaxKind.ArrayLiteralExpression)) {
2550-
// Destructuring assignments are ES6 syntax.
2566+
if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ObjectLiteralExpression) {
2567+
// Destructuring object assignments with are ES2015 syntax
2568+
// and possibly ESNext if they contain rest
2569+
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment;
2570+
}
2571+
else if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ArrayLiteralExpression) {
2572+
// Destructuring assignments are ES2015 syntax.
25512573
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment;
25522574
}
25532575
else if (operatorTokenKind === SyntaxKind.AsteriskAsteriskToken
@@ -2581,6 +2603,11 @@ namespace ts {
25812603
transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsParameterPropertyAssignments;
25822604
}
25832605

2606+
// parameters with object rest destructuring are ES Next syntax
2607+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
2608+
transformFlags |= TransformFlags.AssertESNext;
2609+
}
2610+
25842611
// If a parameter has an initializer, a binding pattern or a dotDotDot token, then
25852612
// it is ES6 syntax and its container must emit default value assignments or parameter destructuring downlevel.
25862613
if (subtreeFlags & TransformFlags.ContainsBindingPattern || initializer || dotDotDotToken) {
@@ -2814,6 +2841,11 @@ namespace ts {
28142841
transformFlags |= TransformFlags.AssertES2017;
28152842
}
28162843

2844+
// function declarations with object rest destructuring are ES Next syntax
2845+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
2846+
transformFlags |= TransformFlags.AssertESNext;
2847+
}
2848+
28172849
// If a FunctionDeclaration's subtree has marked the container as needing to capture the
28182850
// lexical this, or the function contains parameters with initializers, then this node is
28192851
// ES6 syntax.
@@ -2851,6 +2883,12 @@ namespace ts {
28512883
transformFlags |= TransformFlags.AssertES2017;
28522884
}
28532885

2886+
// function expressions with object rest destructuring are ES Next syntax
2887+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
2888+
transformFlags |= TransformFlags.AssertESNext;
2889+
}
2890+
2891+
28542892
// If a FunctionExpression's subtree has marked the container as needing to capture the
28552893
// lexical this, or the function contains parameters with initializers, then this node is
28562894
// ES6 syntax.
@@ -2888,6 +2926,11 @@ namespace ts {
28882926
transformFlags |= TransformFlags.AssertES2017;
28892927
}
28902928

2929+
// arrow functions with object rest destructuring are ES Next syntax
2930+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
2931+
transformFlags |= TransformFlags.AssertESNext;
2932+
}
2933+
28912934
// If an ArrowFunction contains a lexical this, its container must capture the lexical this.
28922935
if (subtreeFlags & TransformFlags.ContainsLexicalThis) {
28932936
transformFlags |= TransformFlags.ContainsCapturedLexicalThis;
@@ -2916,8 +2959,13 @@ namespace ts {
29162959
let transformFlags = subtreeFlags;
29172960
const nameKind = node.name.kind;
29182961

2919-
// A VariableDeclaration with a binding pattern is ES6 syntax.
2920-
if (nameKind === SyntaxKind.ObjectBindingPattern || nameKind === SyntaxKind.ArrayBindingPattern) {
2962+
// A VariableDeclaration with an object binding pattern is ES2015 syntax
2963+
// and possibly ESNext syntax if it contains an object binding pattern
2964+
if (nameKind === SyntaxKind.ObjectBindingPattern) {
2965+
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
2966+
}
2967+
// A VariableDeclaration with an object binding pattern is ES2015 syntax.
2968+
else if (nameKind === SyntaxKind.ArrayBindingPattern) {
29212969
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
29222970
}
29232971

@@ -3058,14 +3106,17 @@ namespace ts {
30583106
transformFlags |= TransformFlags.AssertJsx;
30593107
break;
30603108

3109+
case SyntaxKind.ForOfStatement:
3110+
// for-of might be ESNext if it has a rest destructuring
3111+
transformFlags |= TransformFlags.AssertESNext;
3112+
// FALLTHROUGH
30613113
case SyntaxKind.NoSubstitutionTemplateLiteral:
30623114
case SyntaxKind.TemplateHead:
30633115
case SyntaxKind.TemplateMiddle:
30643116
case SyntaxKind.TemplateTail:
30653117
case SyntaxKind.TemplateExpression:
30663118
case SyntaxKind.TaggedTemplateExpression:
30673119
case SyntaxKind.ShorthandPropertyAssignment:
3068-
case SyntaxKind.ForOfStatement:
30693120
case SyntaxKind.StaticKeyword:
30703121
// These nodes are ES6 syntax.
30713122
transformFlags |= TransformFlags.AssertES2015;
@@ -3130,11 +3181,18 @@ namespace ts {
31303181
}
31313182
break;
31323183

3133-
case SyntaxKind.SpreadElementExpression:
3134-
// This node is ES6 syntax, but is handled by a containing node.
3135-
transformFlags |= TransformFlags.ContainsSpreadElementExpression;
3184+
case SyntaxKind.SpreadElement:
3185+
case SyntaxKind.SpreadAssignment:
3186+
// This node is ES6 or ES next syntax, but is handled by a containing node.
3187+
transformFlags |= TransformFlags.ContainsSpreadExpression;
31363188
break;
31373189

3190+
case SyntaxKind.BindingElement:
3191+
if ((node as BindingElement).dotDotDotToken) {
3192+
// this node is ES2015 or ES next syntax, but is handled by a containing node.
3193+
transformFlags |= TransformFlags.ContainsSpreadExpression;
3194+
}
3195+
31383196
case SyntaxKind.SuperKeyword:
31393197
// This node is ES6 syntax.
31403198
transformFlags |= TransformFlags.AssertES2015;
@@ -3147,8 +3205,13 @@ namespace ts {
31473205

31483206
case SyntaxKind.ObjectBindingPattern:
31493207
case SyntaxKind.ArrayBindingPattern:
3150-
// These nodes are ES6 syntax.
3151-
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
3208+
// These nodes are ES2015 or ES Next syntax.
3209+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
3210+
transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsBindingPattern;
3211+
}
3212+
else {
3213+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
3214+
}
31523215
break;
31533216

31543217
case SyntaxKind.Decorator:
@@ -3170,13 +3233,19 @@ namespace ts {
31703233
transformFlags |= TransformFlags.ContainsLexicalThis;
31713234
}
31723235

3236+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
3237+
// If an ObjectLiteralExpression contains a spread element, then it
3238+
// is an ES next node.
3239+
transformFlags |= TransformFlags.AssertESNext;
3240+
}
3241+
31733242
break;
31743243

31753244
case SyntaxKind.ArrayLiteralExpression:
31763245
case SyntaxKind.NewExpression:
31773246
excludeFlags = TransformFlags.ArrayLiteralOrCallOrNewExcludes;
3178-
if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
3179-
// If the this node contains a SpreadElementExpression, then it is an ES6
3247+
if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
3248+
// If the this node contains a SpreadExpression, then it is an ES6
31803249
// node.
31813250
transformFlags |= TransformFlags.AssertES2015;
31823251
}

0 commit comments

Comments
 (0)