Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit b871b53

Browse filesBrowse files
andrejbaranandrejbaran
committed
Favor use of ES2015 instead of ES6
1 parent c5ddf27 commit b871b53
Copy full SHA for b871b53

21 files changed

+105-105Lines changed: 105 additions & 105 deletions
Expand file treeCollapse file tree
Open diff view settings
Collapse file

‎Jakefile.js‎

Copy file name to clipboardExpand all lines: Jakefile.js
+4-4Lines 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",
Collapse file

‎src/compiler/binder.ts‎

Copy file name to clipboardExpand all lines: src/compiler/binder.ts
+31-31Lines 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 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.