Skip to content

Commit b871b53

Browse files
andrejbaranandrejbaran
committed
Favor use of ES2015 instead of ES6
1 parent c5ddf27 commit b871b53

21 files changed

Lines changed: 105 additions & 105 deletions

‎Jakefile.js‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -70,14 +70,14 @@ var compilerSources = [
7070
"visitor.ts",
7171
"transformers/destructuring.ts",
7272
"transformers/ts.ts",
73-
"transformers/module/es6.ts",
73+
"transformers/module/es2015.ts",
7474
"transformers/module/system.ts",
7575
"transformers/module/module.ts",
7676
"transformers/jsx.ts",
7777
"transformers/es2017.ts",
7878
"transformers/es2016.ts",
79+
"transformers/es2015.ts",
7980
"transformers/generators.ts",
80-
"transformers/es6.ts",
8181
"transformer.ts",
8282
"sourcemap.ts",
8383
"comments.ts",
@@ -105,14 +105,14 @@ var servicesSources = [
105105
"visitor.ts",
106106
"transformers/destructuring.ts",
107107
"transformers/ts.ts",
108-
"transformers/module/es6.ts",
108+
"transformers/module/es2015.ts",
109109
"transformers/module/system.ts",
110110
"transformers/module/module.ts",
111111
"transformers/jsx.ts",
112112
"transformers/es2017.ts",
113113
"transformers/es2016.ts",
114+
"transformers/es2015.ts",
114115
"transformers/generators.ts",
115-
"transformers/es6.ts",
116116
"transformer.ts",
117117
"sourcemap.ts",
118118
"comments.ts",

‎src/compiler/binder.ts‎

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1636,7 +1636,7 @@ namespace ts {
16361636
}
16371637

16381638
function checkStrictModeFunctionDeclaration(node: FunctionDeclaration) {
1639-
if (languageVersion < ScriptTarget.ES6) {
1639+
if (languageVersion < ScriptTarget.ES2015) {
16401640
// Report error if function is not top level function declaration
16411641
if (blockScopeContainer.kind !== SyntaxKind.SourceFile &&
16421642
blockScopeContainer.kind !== SyntaxKind.ModuleDeclaration &&
@@ -2376,7 +2376,7 @@ namespace ts {
23762376
|| isSuperOrSuperProperty(expression, expressionKind)) {
23772377
// If the this node contains a SpreadElementExpression, or is a super call, then it is an ES6
23782378
// node.
2379-
transformFlags |= TransformFlags.AssertES6;
2379+
transformFlags |= TransformFlags.AssertES2015;
23802380
}
23812381

23822382
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2407,7 +2407,7 @@ namespace ts {
24072407
&& (leftKind === SyntaxKind.ObjectLiteralExpression
24082408
|| leftKind === SyntaxKind.ArrayLiteralExpression)) {
24092409
// Destructuring assignments are ES6 syntax.
2410-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.DestructuringAssignment;
2410+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.DestructuringAssignment;
24112411
}
24122412
else if (operatorTokenKind === SyntaxKind.AsteriskAsteriskToken
24132413
|| operatorTokenKind === SyntaxKind.AsteriskAsteriskEqualsToken) {
@@ -2445,7 +2445,7 @@ namespace ts {
24452445
// If a parameter has an initializer, a binding pattern or a dotDotDot token, then
24462446
// it is ES6 syntax and its container must emit default value assignments or parameter destructuring downlevel.
24472447
if (subtreeFlags & TransformFlags.ContainsBindingPattern || initializer || dotDotDotToken) {
2448-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsDefaultValueAssignments;
2448+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsDefaultValueAssignments;
24492449
}
24502450

24512451
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2486,7 +2486,7 @@ namespace ts {
24862486
}
24872487
else {
24882488
// A ClassDeclaration is ES6 syntax.
2489-
transformFlags = subtreeFlags | TransformFlags.AssertES6;
2489+
transformFlags = subtreeFlags | TransformFlags.AssertES2015;
24902490

24912491
// A class with a parameter property assignment, property initializer, or decorator is
24922492
// TypeScript syntax.
@@ -2509,7 +2509,7 @@ namespace ts {
25092509

25102510
function computeClassExpression(node: ClassExpression, subtreeFlags: TransformFlags) {
25112511
// A ClassExpression is ES6 syntax.
2512-
let transformFlags = subtreeFlags | TransformFlags.AssertES6;
2512+
let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
25132513

25142514
// A class with a parameter property assignment, property initializer, or decorator is
25152515
// TypeScript syntax.
@@ -2533,7 +2533,7 @@ namespace ts {
25332533
switch (node.token) {
25342534
case SyntaxKind.ExtendsKeyword:
25352535
// An `extends` HeritageClause is ES6 syntax.
2536-
transformFlags |= TransformFlags.AssertES6;
2536+
transformFlags |= TransformFlags.AssertES2015;
25372537
break;
25382538

25392539
case SyntaxKind.ImplementsKeyword:
@@ -2553,7 +2553,7 @@ namespace ts {
25532553
function computeExpressionWithTypeArguments(node: ExpressionWithTypeArguments, subtreeFlags: TransformFlags) {
25542554
// An ExpressionWithTypeArguments is ES6 syntax, as it is used in the
25552555
// extends clause of a class.
2556-
let transformFlags = subtreeFlags | TransformFlags.AssertES6;
2556+
let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
25572557

25582558
// If an ExpressionWithTypeArguments contains type arguments, then it
25592559
// is TypeScript syntax.
@@ -2580,7 +2580,7 @@ namespace ts {
25802580

25812581
function computeMethod(node: MethodDeclaration, subtreeFlags: TransformFlags) {
25822582
// A MethodDeclaration is ES6 syntax.
2583-
let transformFlags = subtreeFlags | TransformFlags.AssertES6;
2583+
let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
25842584
const modifierFlags = getModifierFlags(node);
25852585
const body = node.body;
25862586
const typeParameters = node.typeParameters;
@@ -2656,7 +2656,7 @@ namespace ts {
26562656

26572657
// If a FunctionDeclaration is exported, then it is either ES6 or TypeScript syntax.
26582658
if (modifierFlags & ModifierFlags.Export) {
2659-
transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.AssertES6;
2659+
transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.AssertES2015;
26602660
}
26612661

26622662
// An async function declaration is ES2017 syntax.
@@ -2667,8 +2667,8 @@ namespace ts {
26672667
// If a FunctionDeclaration's subtree has marked the container as needing to capture the
26682668
// lexical this, or the function contains parameters with initializers, then this node is
26692669
// ES6 syntax.
2670-
if (subtreeFlags & TransformFlags.ES6FunctionSyntaxMask) {
2671-
transformFlags |= TransformFlags.AssertES6;
2670+
if (subtreeFlags & TransformFlags.ES2015FunctionSyntaxMask) {
2671+
transformFlags |= TransformFlags.AssertES2015;
26722672
}
26732673

26742674
// If a FunctionDeclaration is generator function and is the body of a
@@ -2698,8 +2698,8 @@ namespace ts {
26982698
// If a FunctionExpression's subtree has marked the container as needing to capture the
26992699
// lexical this, or the function contains parameters with initializers, then this node is
27002700
// ES6 syntax.
2701-
if (subtreeFlags & TransformFlags.ES6FunctionSyntaxMask) {
2702-
transformFlags |= TransformFlags.AssertES6;
2701+
if (subtreeFlags & TransformFlags.ES2015FunctionSyntaxMask) {
2702+
transformFlags |= TransformFlags.AssertES2015;
27032703
}
27042704

27052705
// If a FunctionExpression is generator function and is the body of a
@@ -2717,7 +2717,7 @@ namespace ts {
27172717

27182718
function computeArrowFunction(node: ArrowFunction, subtreeFlags: TransformFlags) {
27192719
// An ArrowFunction is ES6 syntax, and excludes markers that should not escape the scope of an ArrowFunction.
2720-
let transformFlags = subtreeFlags | TransformFlags.AssertES6;
2720+
let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
27212721
const modifierFlags = getModifierFlags(node);
27222722

27232723
// An async arrow function is ES2017 syntax.
@@ -2755,7 +2755,7 @@ namespace ts {
27552755

27562756
// A VariableDeclaration with a binding pattern is ES6 syntax.
27572757
if (nameKind === SyntaxKind.ObjectBindingPattern || nameKind === SyntaxKind.ArrayBindingPattern) {
2758-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBindingPattern;
2758+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
27592759
}
27602760

27612761
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2776,11 +2776,11 @@ namespace ts {
27762776

27772777
// If a VariableStatement is exported, then it is either ES6 or TypeScript syntax.
27782778
if (modifierFlags & ModifierFlags.Export) {
2779-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
2779+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.AssertTypeScript;
27802780
}
27812781

27822782
if (declarationListTransformFlags & TransformFlags.ContainsBindingPattern) {
2783-
transformFlags |= TransformFlags.AssertES6;
2783+
transformFlags |= TransformFlags.AssertES2015;
27842784
}
27852785
}
27862786

@@ -2794,7 +2794,7 @@ namespace ts {
27942794
// A labeled statement containing a block scoped binding *may* need to be transformed from ES6.
27952795
if (subtreeFlags & TransformFlags.ContainsBlockScopedBinding
27962796
&& isIterationStatement(node, /*lookInLabeledStatements*/ true)) {
2797-
transformFlags |= TransformFlags.AssertES6;
2797+
transformFlags |= TransformFlags.AssertES2015;
27982798
}
27992799

28002800
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2820,7 +2820,7 @@ namespace ts {
28202820
// then we treat the statement as ES6 so that we can indicate that we do not
28212821
// need to hold on to the right-hand side.
28222822
if (node.expression.transformFlags & TransformFlags.DestructuringAssignment) {
2823-
transformFlags |= TransformFlags.AssertES6;
2823+
transformFlags |= TransformFlags.AssertES2015;
28242824
}
28252825

28262826
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2843,12 +2843,12 @@ namespace ts {
28432843
let transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclarationOrCompletion;
28442844

28452845
if (subtreeFlags & TransformFlags.ContainsBindingPattern) {
2846-
transformFlags |= TransformFlags.AssertES6;
2846+
transformFlags |= TransformFlags.AssertES2015;
28472847
}
28482848

28492849
// If a VariableDeclarationList is `let` or `const`, then it is ES6 syntax.
28502850
if (node.flags & NodeFlags.BlockScoped) {
2851-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBlockScopedBinding;
2851+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBlockScopedBinding;
28522852
}
28532853

28542854
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2897,7 +2897,7 @@ namespace ts {
28972897

28982898
case SyntaxKind.ExportKeyword:
28992899
// This node is both ES6 and TypeScript syntax.
2900-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
2900+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.AssertTypeScript;
29012901
break;
29022902

29032903
case SyntaxKind.DefaultKeyword:
@@ -2910,12 +2910,12 @@ namespace ts {
29102910
case SyntaxKind.ShorthandPropertyAssignment:
29112911
case SyntaxKind.ForOfStatement:
29122912
// These nodes are ES6 syntax.
2913-
transformFlags |= TransformFlags.AssertES6;
2913+
transformFlags |= TransformFlags.AssertES2015;
29142914
break;
29152915

29162916
case SyntaxKind.YieldExpression:
29172917
// This node is ES6 syntax.
2918-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsYield;
2918+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
29192919
break;
29202920

29212921
case SyntaxKind.AnyKeyword:
@@ -2976,7 +2976,7 @@ namespace ts {
29762976

29772977
case SyntaxKind.SuperKeyword:
29782978
// This node is ES6 syntax.
2979-
transformFlags |= TransformFlags.AssertES6;
2979+
transformFlags |= TransformFlags.AssertES2015;
29802980
break;
29812981

29822982
case SyntaxKind.ThisKeyword:
@@ -2987,7 +2987,7 @@ namespace ts {
29872987
case SyntaxKind.ObjectBindingPattern:
29882988
case SyntaxKind.ArrayBindingPattern:
29892989
// These nodes are ES6 syntax.
2990-
transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBindingPattern;
2990+
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
29912991
break;
29922992

29932993
case SyntaxKind.Decorator:
@@ -3000,7 +3000,7 @@ namespace ts {
30003000
if (subtreeFlags & TransformFlags.ContainsComputedPropertyName) {
30013001
// If an ObjectLiteralExpression contains a ComputedPropertyName, then it
30023002
// is an ES6 node.
3003-
transformFlags |= TransformFlags.AssertES6;
3003+
transformFlags |= TransformFlags.AssertES2015;
30043004
}
30053005

30063006
if (subtreeFlags & TransformFlags.ContainsLexicalThisInComputedPropertyName) {
@@ -3017,7 +3017,7 @@ namespace ts {
30173017
if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
30183018
// If the this node contains a SpreadElementExpression, then it is an ES6
30193019
// node.
3020-
transformFlags |= TransformFlags.AssertES6;
3020+
transformFlags |= TransformFlags.AssertES2015;
30213021
}
30223022

30233023
break;
@@ -3028,14 +3028,14 @@ namespace ts {
30283028
case SyntaxKind.ForInStatement:
30293029
// A loop containing a block scoped binding *may* need to be transformed from ES6.
30303030
if (subtreeFlags & TransformFlags.ContainsBlockScopedBinding) {
3031-
transformFlags |= TransformFlags.AssertES6;
3031+
transformFlags |= TransformFlags.AssertES2015;
30323032
}
30333033

30343034
break;
30353035

30363036
case SyntaxKind.SourceFile:
30373037
if (subtreeFlags & TransformFlags.ContainsCapturedLexicalThis) {
3038-
transformFlags |= TransformFlags.AssertES6;
3038+
transformFlags |= TransformFlags.AssertES2015;
30393039
}
30403040

30413041
break;

0 commit comments

Comments
 (0)