diff --git a/Jakefile.js b/Jakefile.js
index 8d46368653c..6f86ef35b09 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -70,14 +70,14 @@ var compilerSources = [
     "visitor.ts",
     "transformers/destructuring.ts",
     "transformers/ts.ts",
-    "transformers/module/es6.ts",
+    "transformers/module/es2015.ts",
     "transformers/module/system.ts",
     "transformers/module/module.ts",
     "transformers/jsx.ts",
     "transformers/es2017.ts",
     "transformers/es2016.ts",
+    "transformers/es2015.ts",
     "transformers/generators.ts",
-    "transformers/es6.ts",
     "transformer.ts",
     "sourcemap.ts",
     "comments.ts",
@@ -105,14 +105,14 @@ var servicesSources = [
     "visitor.ts",
     "transformers/destructuring.ts",
     "transformers/ts.ts",
-    "transformers/module/es6.ts",
+    "transformers/module/es2015.ts",
     "transformers/module/system.ts",
     "transformers/module/module.ts",
     "transformers/jsx.ts",
     "transformers/es2017.ts",
     "transformers/es2016.ts",
+    "transformers/es2015.ts",
     "transformers/generators.ts",
-    "transformers/es6.ts",
     "transformer.ts",
     "sourcemap.ts",
     "comments.ts",
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 3f5db2ae7c5..970e481faaa 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1636,7 +1636,7 @@ namespace ts {
         }
 
         function checkStrictModeFunctionDeclaration(node: FunctionDeclaration) {
-            if (languageVersion < ScriptTarget.ES6) {
+            if (languageVersion < ScriptTarget.ES2015) {
                 // Report error if function is not top level function declaration
                 if (blockScopeContainer.kind !== SyntaxKind.SourceFile &&
                     blockScopeContainer.kind !== SyntaxKind.ModuleDeclaration &&
@@ -2376,7 +2376,7 @@ namespace ts {
             || isSuperOrSuperProperty(expression, expressionKind)) {
             // If the this node contains a SpreadElementExpression, or is a super call, then it is an ES6
             // node.
-            transformFlags |= TransformFlags.AssertES6;
+            transformFlags |= TransformFlags.AssertES2015;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2407,7 +2407,7 @@ namespace ts {
             && (leftKind === SyntaxKind.ObjectLiteralExpression
                 || leftKind === SyntaxKind.ArrayLiteralExpression)) {
             // Destructuring assignments are ES6 syntax.
-            transformFlags |= TransformFlags.AssertES6 | TransformFlags.DestructuringAssignment;
+            transformFlags |= TransformFlags.AssertES2015 | TransformFlags.DestructuringAssignment;
         }
         else if (operatorTokenKind === SyntaxKind.AsteriskAsteriskToken
             || operatorTokenKind === SyntaxKind.AsteriskAsteriskEqualsToken) {
@@ -2445,7 +2445,7 @@ namespace ts {
         // If a parameter has an initializer, a binding pattern or a dotDotDot token, then
         // it is ES6 syntax and its container must emit default value assignments or parameter destructuring downlevel.
         if (subtreeFlags & TransformFlags.ContainsBindingPattern || initializer || dotDotDotToken) {
-            transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsDefaultValueAssignments;
+            transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsDefaultValueAssignments;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2486,7 +2486,7 @@ namespace ts {
         }
         else {
             // A ClassDeclaration is ES6 syntax.
-            transformFlags = subtreeFlags | TransformFlags.AssertES6;
+            transformFlags = subtreeFlags | TransformFlags.AssertES2015;
 
             // A class with a parameter property assignment, property initializer, or decorator is
             // TypeScript syntax.
@@ -2509,7 +2509,7 @@ namespace ts {
 
     function computeClassExpression(node: ClassExpression, subtreeFlags: TransformFlags) {
         // A ClassExpression is ES6 syntax.
-        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+        let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
 
         // A class with a parameter property assignment, property initializer, or decorator is
         // TypeScript syntax.
@@ -2533,7 +2533,7 @@ namespace ts {
         switch (node.token) {
             case SyntaxKind.ExtendsKeyword:
                 // An `extends` HeritageClause is ES6 syntax.
-                transformFlags |= TransformFlags.AssertES6;
+                transformFlags |= TransformFlags.AssertES2015;
                 break;
 
             case SyntaxKind.ImplementsKeyword:
@@ -2553,7 +2553,7 @@ namespace ts {
     function computeExpressionWithTypeArguments(node: ExpressionWithTypeArguments, subtreeFlags: TransformFlags) {
         // An ExpressionWithTypeArguments is ES6 syntax, as it is used in the
         // extends clause of a class.
-        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+        let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
 
         // If an ExpressionWithTypeArguments contains type arguments, then it
         // is TypeScript syntax.
@@ -2580,7 +2580,7 @@ namespace ts {
 
     function computeMethod(node: MethodDeclaration, subtreeFlags: TransformFlags) {
         // A MethodDeclaration is ES6 syntax.
-        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+        let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
         const modifierFlags = getModifierFlags(node);
         const body = node.body;
         const typeParameters = node.typeParameters;
@@ -2656,7 +2656,7 @@ namespace ts {
 
             // If a FunctionDeclaration is exported, then it is either ES6 or TypeScript syntax.
             if (modifierFlags & ModifierFlags.Export) {
-                transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.AssertES6;
+                transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.AssertES2015;
             }
 
             // An async function declaration is ES2017 syntax.
@@ -2667,8 +2667,8 @@ namespace ts {
             // If a FunctionDeclaration's subtree has marked the container as needing to capture the
             // lexical this, or the function contains parameters with initializers, then this node is
             // ES6 syntax.
-            if (subtreeFlags & TransformFlags.ES6FunctionSyntaxMask) {
-                transformFlags |= TransformFlags.AssertES6;
+            if (subtreeFlags & TransformFlags.ES2015FunctionSyntaxMask) {
+                transformFlags |= TransformFlags.AssertES2015;
             }
 
             // If a FunctionDeclaration is generator function and is the body of a
@@ -2698,8 +2698,8 @@ namespace ts {
         // If a FunctionExpression's subtree has marked the container as needing to capture the
         // lexical this, or the function contains parameters with initializers, then this node is
         // ES6 syntax.
-        if (subtreeFlags & TransformFlags.ES6FunctionSyntaxMask) {
-            transformFlags |= TransformFlags.AssertES6;
+        if (subtreeFlags & TransformFlags.ES2015FunctionSyntaxMask) {
+            transformFlags |= TransformFlags.AssertES2015;
         }
 
         // If a FunctionExpression is generator function and is the body of a
@@ -2717,7 +2717,7 @@ namespace ts {
 
     function computeArrowFunction(node: ArrowFunction, subtreeFlags: TransformFlags) {
         // An ArrowFunction is ES6 syntax, and excludes markers that should not escape the scope of an ArrowFunction.
-        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+        let transformFlags = subtreeFlags | TransformFlags.AssertES2015;
         const modifierFlags = getModifierFlags(node);
 
         // An async arrow function is ES2017 syntax.
@@ -2755,7 +2755,7 @@ namespace ts {
 
         // A VariableDeclaration with a binding pattern is ES6 syntax.
         if (nameKind === SyntaxKind.ObjectBindingPattern || nameKind === SyntaxKind.ArrayBindingPattern) {
-            transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBindingPattern;
+            transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2776,11 +2776,11 @@ namespace ts {
 
             // If a VariableStatement is exported, then it is either ES6 or TypeScript syntax.
             if (modifierFlags & ModifierFlags.Export) {
-                transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
+                transformFlags |= TransformFlags.AssertES2015 | TransformFlags.AssertTypeScript;
             }
 
             if (declarationListTransformFlags & TransformFlags.ContainsBindingPattern) {
-                transformFlags |= TransformFlags.AssertES6;
+                transformFlags |= TransformFlags.AssertES2015;
             }
         }
 
@@ -2794,7 +2794,7 @@ namespace ts {
         // A labeled statement containing a block scoped binding *may* need to be transformed from ES6.
         if (subtreeFlags & TransformFlags.ContainsBlockScopedBinding
             && isIterationStatement(node, /*lookInLabeledStatements*/ true)) {
-            transformFlags |= TransformFlags.AssertES6;
+            transformFlags |= TransformFlags.AssertES2015;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2820,7 +2820,7 @@ namespace ts {
         // then we treat the statement as ES6 so that we can indicate that we do not
         // need to hold on to the right-hand side.
         if (node.expression.transformFlags & TransformFlags.DestructuringAssignment) {
-            transformFlags |= TransformFlags.AssertES6;
+            transformFlags |= TransformFlags.AssertES2015;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2843,12 +2843,12 @@ namespace ts {
         let transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclarationOrCompletion;
 
         if (subtreeFlags & TransformFlags.ContainsBindingPattern) {
-            transformFlags |= TransformFlags.AssertES6;
+            transformFlags |= TransformFlags.AssertES2015;
         }
 
         // If a VariableDeclarationList is `let` or `const`, then it is ES6 syntax.
         if (node.flags & NodeFlags.BlockScoped) {
-            transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBlockScopedBinding;
+            transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBlockScopedBinding;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -2897,7 +2897,7 @@ namespace ts {
 
             case SyntaxKind.ExportKeyword:
                 // This node is both ES6 and TypeScript syntax.
-                transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
+                transformFlags |= TransformFlags.AssertES2015 | TransformFlags.AssertTypeScript;
                 break;
 
             case SyntaxKind.DefaultKeyword:
@@ -2910,12 +2910,12 @@ namespace ts {
             case SyntaxKind.ShorthandPropertyAssignment:
             case SyntaxKind.ForOfStatement:
                 // These nodes are ES6 syntax.
-                transformFlags |= TransformFlags.AssertES6;
+                transformFlags |= TransformFlags.AssertES2015;
                 break;
 
             case SyntaxKind.YieldExpression:
                 // This node is ES6 syntax.
-                transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsYield;
+                transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
                 break;
 
             case SyntaxKind.AnyKeyword:
@@ -2976,7 +2976,7 @@ namespace ts {
 
             case SyntaxKind.SuperKeyword:
                 // This node is ES6 syntax.
-                transformFlags |= TransformFlags.AssertES6;
+                transformFlags |= TransformFlags.AssertES2015;
                 break;
 
             case SyntaxKind.ThisKeyword:
@@ -2987,7 +2987,7 @@ namespace ts {
             case SyntaxKind.ObjectBindingPattern:
             case SyntaxKind.ArrayBindingPattern:
                 // These nodes are ES6 syntax.
-                transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBindingPattern;
+                transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
                 break;
 
             case SyntaxKind.Decorator:
@@ -3000,7 +3000,7 @@ namespace ts {
                 if (subtreeFlags & TransformFlags.ContainsComputedPropertyName) {
                     // If an ObjectLiteralExpression contains a ComputedPropertyName, then it
                     // is an ES6 node.
-                    transformFlags |= TransformFlags.AssertES6;
+                    transformFlags |= TransformFlags.AssertES2015;
                 }
 
                 if (subtreeFlags & TransformFlags.ContainsLexicalThisInComputedPropertyName) {
@@ -3017,7 +3017,7 @@ namespace ts {
                 if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
                     // If the this node contains a SpreadElementExpression, then it is an ES6
                     // node.
-                    transformFlags |= TransformFlags.AssertES6;
+                    transformFlags |= TransformFlags.AssertES2015;
                 }
 
                 break;
@@ -3028,14 +3028,14 @@ namespace ts {
             case SyntaxKind.ForInStatement:
                 // A loop containing a block scoped binding *may* need to be transformed from ES6.
                 if (subtreeFlags & TransformFlags.ContainsBlockScopedBinding) {
-                    transformFlags |= TransformFlags.AssertES6;
+                    transformFlags |= TransformFlags.AssertES2015;
                 }
 
                 break;
 
             case SyntaxKind.SourceFile:
                 if (subtreeFlags & TransformFlags.ContainsCapturedLexicalThis) {
-                    transformFlags |= TransformFlags.AssertES6;
+                    transformFlags |= TransformFlags.AssertES2015;
                 }
 
                 break;
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 0b5c3963079..cecf2964f3c 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3189,7 +3189,7 @@ namespace ts {
             const elements = pattern.elements;
             const lastElement = lastOrUndefined(elements);
             if (elements.length === 0 || (!isOmittedExpression(lastElement) && lastElement.dotDotDotToken)) {
-                return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType;
+                return languageVersion >= ScriptTarget.ES2015 ? createIterableType(anyType) : anyArrayType;
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
             const elementTypes = map(elements, e => isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors));
@@ -9059,7 +9059,7 @@ namespace ts {
             // can explicitly bound arguments objects
             if (symbol === argumentsSymbol) {
                 const container = getContainingFunction(node);
-                if (languageVersion < ScriptTarget.ES6) {
+                if (languageVersion < ScriptTarget.ES2015) {
                     if (container.kind === SyntaxKind.ArrowFunction) {
                         error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
                     }
@@ -9084,7 +9084,7 @@ namespace ts {
                 // Due to the emit for class decorators, any reference to the class from inside of the class body
                 // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
                 // behavior of class names in ES6.
-                if (languageVersion === ScriptTarget.ES6
+                if (languageVersion === ScriptTarget.ES2015
                     && declaration.kind === SyntaxKind.ClassDeclaration
                     && nodeIsDecorated(declaration)) {
                     let container = getContainingClass(node);
@@ -9173,7 +9173,7 @@ namespace ts {
         }
 
         function checkNestedBlockScopedBinding(node: Identifier, symbol: Symbol): void {
-            if (languageVersion >= ScriptTarget.ES6 ||
+            if (languageVersion >= ScriptTarget.ES2015 ||
                 (symbol.flags & (SymbolFlags.BlockScopedVariable | SymbolFlags.Class)) === 0 ||
                 symbol.valueDeclaration.parent.kind === SyntaxKind.CatchClause) {
                 return;
@@ -9339,7 +9339,7 @@ namespace ts {
                 container = getThisContainer(container, /* includeArrowFunctions */ false);
 
                 // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code
-                needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6);
+                needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES2015);
             }
 
             switch (container.kind) {
@@ -9447,7 +9447,7 @@ namespace ts {
             if (!isCallExpression) {
                 while (container && container.kind === SyntaxKind.ArrowFunction) {
                     container = getSuperContainer(container, /*stopOnFunctions*/ true);
-                    needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6;
+                    needToCaptureLexicalThis = languageVersion < ScriptTarget.ES2015;
                 }
             }
 
@@ -9561,7 +9561,7 @@ namespace ts {
             }
 
             if (container.parent.kind === SyntaxKind.ObjectLiteralExpression) {
-                if (languageVersion < ScriptTarget.ES6) {
+                if (languageVersion < ScriptTarget.ES2015) {
                     error(node, Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
                     return unknownType;
                 }
@@ -9929,7 +9929,7 @@ namespace ts {
                 const index = indexOf(arrayLiteral.elements, node);
                 return getTypeOfPropertyOfContextualType(type, "" + index)
                     || getIndexTypeOfContextualType(type, IndexKind.Number)
-                    || (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(type, /*errorNode*/ undefined) : undefined);
+                    || (languageVersion >= ScriptTarget.ES2015 ? getElementTypeOfIterable(type, /*errorNode*/ undefined) : undefined);
             }
             return undefined;
         }
@@ -10162,7 +10162,7 @@ namespace ts {
                     // if there is no index type / iterated type.
                     const restArrayType = checkExpression((<SpreadElementExpression>e).expression, contextualMapper);
                     const restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
-                        (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
+                        (languageVersion >= ScriptTarget.ES2015 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
                     if (restElementType) {
                         elementTypes.push(restElementType);
                     }
@@ -10909,7 +10909,7 @@ namespace ts {
                 // - In a static member function or static member accessor
                 //   where this references the constructor function object of a derived class,
                 //   a super property access is permitted and must specify a public static member function of the base class.
-                if (languageVersion < ScriptTarget.ES6 && getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) {
+                if (languageVersion < ScriptTarget.ES2015 && getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) {
                     // `prop` refers to a *property* declared in the super class
                     // rather than a *method*, so it does not satisfy the above criteria.
 
@@ -14228,7 +14228,7 @@ namespace ts {
                 }
 
                 if (node.type) {
-                    if (languageVersion >= ScriptTarget.ES6 && isSyntacticallyValidGenerator(node)) {
+                    if (languageVersion >= ScriptTarget.ES2015 && isSyntacticallyValidGenerator(node)) {
                         const returnType = getTypeFromTypeNode(node.type);
                         if (returnType === voidType) {
                             error(node.type, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
@@ -15189,7 +15189,7 @@ namespace ts {
           * callable `then` signature.
           */
         function checkAsyncFunctionReturnType(node: FunctionLikeDeclaration): Type {
-            if (languageVersion >= ScriptTarget.ES6) {
+            if (languageVersion >= ScriptTarget.ES2015) {
                 const returnType = getTypeFromTypeNode(node.type);
                 return checkCorrectPromiseType(returnType, node.type, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
             }
@@ -15722,7 +15722,7 @@ namespace ts {
 
         function checkCollisionWithRequireExportsInGeneratedCode(node: Node, name: Identifier) {
             // No need to check for require or exports for ES6 modules and later
-            if (modulekind >= ModuleKind.ES6) {
+            if (modulekind >= ModuleKind.ES2015) {
                 return;
             }
 
@@ -16214,7 +16214,7 @@ namespace ts {
             if (isTypeAny(inputType)) {
                 return inputType;
             }
-            if (languageVersion >= ScriptTarget.ES6) {
+            if (languageVersion >= ScriptTarget.ES2015) {
                 return checkElementTypeOfIterable(inputType, errorNode);
             }
             if (allowStringInput) {
@@ -16392,7 +16392,7 @@ namespace ts {
          *   2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable).
          */
         function checkElementTypeOfArrayOrString(arrayOrStringType: Type, errorNode: Node): Type {
-            Debug.assert(languageVersion < ScriptTarget.ES6);
+            Debug.assert(languageVersion < ScriptTarget.ES2015);
 
             // After we remove all types that are StringLike, we will know if there was a string constituent
             // based on whether the remaining type is the same as the initial type.
@@ -17700,7 +17700,7 @@ namespace ts {
                     }
                 }
                 else {
-                    if (modulekind === ModuleKind.ES6 && !isInAmbientContext(node)) {
+                    if (modulekind === ModuleKind.ES2015 && !isInAmbientContext(node)) {
                         // Import equals declaration is deprecated in es6 or above
                         grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
                     }
@@ -17788,7 +17788,7 @@ namespace ts {
             checkExternalModuleExports(container);
 
             if (node.isExportEquals && !isInAmbientContext(node)) {
-                if (modulekind === ModuleKind.ES6) {
+                if (modulekind === ModuleKind.ES2015) {
                     // export assignment is not supported in es6 modules
                     grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_export_default_or_another_module_format_instead);
                 }
@@ -19296,7 +19296,7 @@ namespace ts {
 
             getGlobalTemplateStringsArrayType = memoize(() => getGlobalType("TemplateStringsArray"));
 
-            if (languageVersion >= ScriptTarget.ES6) {
+            if (languageVersion >= ScriptTarget.ES2015) {
                 getGlobalESSymbolType = memoize(() => getGlobalType("Symbol"));
                 getGlobalIterableType = memoize(() => <GenericType>getGlobalType("Iterable", /*arity*/ 1));
                 getGlobalIteratorType = memoize(() => <GenericType>getGlobalType("Iterator", /*arity*/ 1));
@@ -19329,7 +19329,7 @@ namespace ts {
                 // If we found the module, report errors if it does not have the necessary exports.
                 if (helpersModule) {
                     const exports = helpersModule.exports;
-                    if (requestedExternalEmitHelpers & NodeFlags.HasClassExtends && languageVersion < ScriptTarget.ES6) {
+                    if (requestedExternalEmitHelpers & NodeFlags.HasClassExtends && languageVersion < ScriptTarget.ES2015) {
                         verifyHelperSymbol(exports, "__extends", SymbolFlags.Value);
                     }
                     if (requestedExternalEmitHelpers & NodeFlags.HasJsxSpreadAttributes && compilerOptions.jsx !== JsxEmit.Preserve) {
@@ -19346,7 +19346,7 @@ namespace ts {
                     }
                     if (requestedExternalEmitHelpers & NodeFlags.HasAsyncFunctions) {
                         verifyHelperSymbol(exports, "__awaiter", SymbolFlags.Value);
-                        if (languageVersion < ScriptTarget.ES6) {
+                        if (languageVersion < ScriptTarget.ES2015) {
                             verifyHelperSymbol(exports, "__generator", SymbolFlags.Value);
                         }
                     }
@@ -19923,7 +19923,7 @@ namespace ts {
                 if (!node.body) {
                     return grammarErrorOnNode(node.asteriskToken, Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
                 }
-                if (languageVersion < ScriptTarget.ES6) {
+                if (languageVersion < ScriptTarget.ES2015) {
                     return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher);
                 }
             }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 3f2cc619cb3..3f60ec62c2b 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1191,7 +1191,7 @@ namespace ts {
     export function getEmitModuleKind(compilerOptions: CompilerOptions) {
         return typeof compilerOptions.module === "number" ?
             compilerOptions.module :
-            getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.CommonJS;
+            getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015 ? ModuleKind.ES2015 : ModuleKind.CommonJS;
     }
 
     /* @internal */
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index a3f69e2fd4b..734fe2778e5 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -2165,7 +2165,7 @@ const _super = (function (geti, seti) {
 
             // Only Emit __extends function when target ES5.
             // For target ES6 and above, we can emit classDeclaration as is.
-            if ((languageVersion < ScriptTarget.ES6) && (!extendsEmitted && node.flags & NodeFlags.HasClassExtends)) {
+            if ((languageVersion < ScriptTarget.ES2015) && (!extendsEmitted && node.flags & NodeFlags.HasClassExtends)) {
                 writeLines(extendsHelper);
                 extendsEmitted = true;
                 helpersEmitted = true;
@@ -2197,7 +2197,7 @@ const _super = (function (geti, seti) {
             // For target ES2017 and above, we can emit async/await as is.
             if ((languageVersion < ScriptTarget.ES2017) && (!awaiterEmitted && node.flags & NodeFlags.HasAsyncFunctions)) {
                 writeLines(awaiterHelper);
-                if (languageVersion < ScriptTarget.ES6) {
+                if (languageVersion < ScriptTarget.ES2015) {
                     writeLines(generatorHelper);
                 }
 
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 519269ccfd0..57007619c62 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -1985,7 +1985,7 @@ namespace ts {
         }
         else if (callee.kind === SyntaxKind.SuperKeyword) {
             thisArg = createThis();
-            target = languageVersion < ScriptTarget.ES6 ? createIdentifier("_super", /*location*/ callee) : <PrimaryExpression>callee;
+            target = languageVersion < ScriptTarget.ES2015 ? createIdentifier("_super", /*location*/ callee) : <PrimaryExpression>callee;
         }
         else {
             switch (callee.kind) {
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 5d46038b2b1..dfe65fc0860 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -1478,7 +1478,7 @@ namespace ts {
 
             const firstNonAmbientExternalModuleSourceFile = forEach(files, f => isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
             if (options.isolatedModules) {
-                if (options.module === ModuleKind.None && languageVersion < ScriptTarget.ES6) {
+                if (options.module === ModuleKind.None && languageVersion < ScriptTarget.ES2015) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher));
                 }
 
@@ -1488,7 +1488,7 @@ namespace ts {
                     programDiagnostics.add(createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided));
                 }
             }
-            else if (firstNonAmbientExternalModuleSourceFile && languageVersion < ScriptTarget.ES6 && options.module === ModuleKind.None) {
+            else if (firstNonAmbientExternalModuleSourceFile && languageVersion < ScriptTarget.ES2015 && options.module === ModuleKind.None) {
                 // We cannot use createDiagnosticFromNode because nodes do not have parents yet
                 const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
                 programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index 55b83ea669d..fc656e08bf9 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -3,16 +3,16 @@
 /// <reference path="transformers/jsx.ts" />
 /// <reference path="transformers/es2017.ts" />
 /// <reference path="transformers/es2016.ts" />
-/// <reference path="transformers/es6.ts" />
+/// <reference path="transformers/es2015.ts" />
 /// <reference path="transformers/generators.ts" />
 /// <reference path="transformers/module/module.ts" />
 /// <reference path="transformers/module/system.ts" />
-/// <reference path="transformers/module/es6.ts" />
+/// <reference path="transformers/module/es2015.ts" />
 
 /* @internal */
 namespace ts {
     const moduleTransformerMap = createMap<Transformer>({
-        [ModuleKind.ES6]: transformES6Module,
+        [ModuleKind.ES2015]: transformES2015Module,
         [ModuleKind.System]: transformSystemModule,
         [ModuleKind.AMD]: transformModule,
         [ModuleKind.CommonJS]: transformModule,
@@ -124,8 +124,8 @@ namespace ts {
             transformers.push(transformES2016);
         }
 
-        if (languageVersion < ScriptTarget.ES6) {
-            transformers.push(transformES6);
+        if (languageVersion < ScriptTarget.ES2015) {
+            transformers.push(transformES2015);
             transformers.push(transformGenerators);
         }
 
diff --git a/src/compiler/transformers/es6.ts b/src/compiler/transformers/es2015.ts
similarity index 97%
rename from src/compiler/transformers/es6.ts
rename to src/compiler/transformers/es2015.ts
index ba5f8a3fb77..101c34a8199 100644
--- a/src/compiler/transformers/es6.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -4,7 +4,7 @@
 /*@internal*/
 namespace ts {
 
-    const enum ES6SubstitutionFlags {
+    const enum ES2015SubstitutionFlags {
         /** Enables substitutions for captured `this` */
         CapturedThis = 1 << 0,
         /** Enables substitutions for block-scoped bindings. */
@@ -163,7 +163,7 @@ namespace ts {
         ReplaceWithReturn,
     }
 
-    export function transformES6(context: TransformationContext) {
+    export function transformES2015(context: TransformationContext) {
         const {
             startLexicalEnvironment,
             endLexicalEnvironment,
@@ -197,7 +197,7 @@ namespace ts {
          * They are persisted between each SourceFile transformation and should not
          * be reset.
          */
-        let enabledSubstitutions: ES6SubstitutionFlags;
+        let enabledSubstitutions: ES2015SubstitutionFlags;
 
         return transformSourceFile;
 
@@ -252,7 +252,7 @@ namespace ts {
         }
 
         function shouldCheckNode(node: Node): boolean {
-            return (node.transformFlags & TransformFlags.ES6) !== 0 ||
+            return (node.transformFlags & TransformFlags.ES2015) !== 0 ||
                 node.kind === SyntaxKind.LabeledStatement ||
                 (isIterationStatement(node, /*lookInLabeledStatements*/ false) && shouldConvertIterationStatementBody(node));
         }
@@ -261,7 +261,7 @@ namespace ts {
             if (shouldCheckNode(node)) {
                 return visitJavaScript(node);
             }
-            else if (node.transformFlags & TransformFlags.ContainsES6) {
+            else if (node.transformFlags & TransformFlags.ContainsES2015) {
                 return visitEachChild(node, visitor, context);
             }
             else {
@@ -3037,7 +3037,7 @@ namespace ts {
         function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
             const savedEnclosingFunction = enclosingFunction;
 
-            if (enabledSubstitutions & ES6SubstitutionFlags.CapturedThis && isFunctionLike(node)) {
+            if (enabledSubstitutions & ES2015SubstitutionFlags.CapturedThis && isFunctionLike(node)) {
                 // If we are tracking a captured `this`, keep track of the enclosing function.
                 enclosingFunction = node;
             }
@@ -3052,8 +3052,8 @@ namespace ts {
          * contains block-scoped bindings (e.g. `let` or `const`).
          */
         function enableSubstitutionsForBlockScopedBindings() {
-            if ((enabledSubstitutions & ES6SubstitutionFlags.BlockScopedBindings) === 0) {
-                enabledSubstitutions |= ES6SubstitutionFlags.BlockScopedBindings;
+            if ((enabledSubstitutions & ES2015SubstitutionFlags.BlockScopedBindings) === 0) {
+                enabledSubstitutions |= ES2015SubstitutionFlags.BlockScopedBindings;
                 context.enableSubstitution(SyntaxKind.Identifier);
             }
         }
@@ -3063,8 +3063,8 @@ namespace ts {
          * contains a captured `this`.
          */
         function enableSubstitutionsForCapturedThis() {
-            if ((enabledSubstitutions & ES6SubstitutionFlags.CapturedThis) === 0) {
-                enabledSubstitutions |= ES6SubstitutionFlags.CapturedThis;
+            if ((enabledSubstitutions & ES2015SubstitutionFlags.CapturedThis) === 0) {
+                enabledSubstitutions |= ES2015SubstitutionFlags.CapturedThis;
                 context.enableSubstitution(SyntaxKind.ThisKeyword);
                 context.enableEmitNotification(SyntaxKind.Constructor);
                 context.enableEmitNotification(SyntaxKind.MethodDeclaration);
@@ -3103,7 +3103,7 @@ namespace ts {
         function substituteIdentifier(node: Identifier) {
             // Only substitute the identifier if we have enabled substitutions for block-scoped
             // bindings.
-            if (enabledSubstitutions & ES6SubstitutionFlags.BlockScopedBindings) {
+            if (enabledSubstitutions & ES2015SubstitutionFlags.BlockScopedBindings) {
                 const original = getParseTreeNode(node, isIdentifier);
                 if (original && isNameOfDeclarationWithCollidingName(original)) {
                     return getGeneratedNameForNode(original);
@@ -3156,7 +3156,7 @@ namespace ts {
          * @param node An Identifier node.
          */
         function substituteExpressionIdentifier(node: Identifier): Identifier {
-            if (enabledSubstitutions & ES6SubstitutionFlags.BlockScopedBindings) {
+            if (enabledSubstitutions & ES2015SubstitutionFlags.BlockScopedBindings) {
                 const declaration = resolver.getReferencedDeclarationWithCollidingName(node);
                 if (declaration) {
                     return getGeneratedNameForNode(declaration.name);
@@ -3172,7 +3172,7 @@ namespace ts {
          * @param node The ThisKeyword node.
          */
         function substituteThisKeyword(node: PrimaryExpression): PrimaryExpression {
-            if (enabledSubstitutions & ES6SubstitutionFlags.CapturedThis
+            if (enabledSubstitutions & ES2015SubstitutionFlags.CapturedThis
                 && enclosingFunction
                 && getEmitFlags(enclosingFunction) & EmitFlags.CapturesThis) {
                 return createIdentifier("_this", /*location*/ node);
diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts
index f9e8b539c6a..7800a41e147 100644
--- a/src/compiler/transformers/es2017.ts
+++ b/src/compiler/transformers/es2017.ts
@@ -263,7 +263,7 @@ namespace ts {
 
         function transformAsyncFunctionBody(node: FunctionLikeDeclaration): ConciseBody | FunctionBody {
             const nodeType = node.original ? (<FunctionLikeDeclaration>node.original).type : node.type;
-            const promiseConstructor = languageVersion < ScriptTarget.ES6 ? getPromiseConstructor(nodeType) : undefined;
+            const promiseConstructor = languageVersion < ScriptTarget.ES2015 ? getPromiseConstructor(nodeType) : undefined;
             const isArrowFunction = node.kind === SyntaxKind.ArrowFunction;
             const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0;
 
@@ -292,7 +292,7 @@ namespace ts {
 
                 // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
                 // This step isn't needed if we eventually transform this to ES5.
-                if (languageVersion >= ScriptTarget.ES6) {
+                if (languageVersion >= ScriptTarget.ES2015) {
                     if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) {
                         enableSubstitutionForAsyncMethodsWithSuper();
                         setEmitFlags(block, EmitFlags.EmitAdvancedSuperHelper);
diff --git a/src/compiler/transformers/module/es6.ts b/src/compiler/transformers/module/es2015.ts
similarity index 96%
rename from src/compiler/transformers/module/es6.ts
rename to src/compiler/transformers/module/es2015.ts
index 09a2890727c..b06acd2d091 100644
--- a/src/compiler/transformers/module/es6.ts
+++ b/src/compiler/transformers/module/es2015.ts
@@ -3,7 +3,7 @@
 
 /*@internal*/
 namespace ts {
-    export function transformES6Module(context: TransformationContext) {
+    export function transformES2015Module(context: TransformationContext) {
         const compilerOptions = context.getCompilerOptions();
         const resolver = context.getEmitResolver();
 
@@ -141,4 +141,4 @@ namespace ts {
             return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index 9051f375bf9..989efbfd53f 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -416,7 +416,7 @@ namespace ts {
                                 )
                             ],
                             /*location*/ undefined,
-                            /*flags*/ languageVersion >= ScriptTarget.ES6 ? NodeFlags.Const : NodeFlags.None),
+                            /*flags*/ languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None),
                             /*location*/ node
                         )
                     );
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 77ab6a6ca0e..868c371e00f 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -1777,7 +1777,7 @@ namespace ts {
                     return createIdentifier("Number");
 
                 case SyntaxKind.SymbolKeyword:
-                    return languageVersion < ScriptTarget.ES6
+                    return languageVersion < ScriptTarget.ES2015
                         ? getGlobalSymbolNameWithFallback()
                         : createIdentifier("Symbol");
 
@@ -1843,7 +1843,7 @@ namespace ts {
                     return createIdentifier("Array");
 
                 case TypeReferenceSerializationKind.ESSymbolType:
-                    return languageVersion < ScriptTarget.ES6
+                    return languageVersion < ScriptTarget.ES2015
                         ? getGlobalSymbolNameWithFallback()
                         : createIdentifier("Symbol");
 
@@ -2592,7 +2592,7 @@ namespace ts {
 
         function isES6ExportedDeclaration(node: Node) {
             return isExternalModuleExport(node)
-                && moduleKind === ModuleKind.ES6;
+                && moduleKind === ModuleKind.ES2015;
         }
 
         /**
diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index de710e74a46..da356c0b4d3 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -26,12 +26,12 @@
         "transformers/jsx.ts",
         "transformers/es2017.ts",
         "transformers/es2016.ts",
-        "transformers/es6.ts",
+        "transformers/es2015.ts",
         "transformers/generators.ts",
         "transformers/destructuring.ts",
         "transformers/module/module.ts",
         "transformers/module/system.ts",
-        "transformers/module/es6.ts",
+        "transformers/module/es2015.ts",
         "transformer.ts",
         "comments.ts",
         "sourcemap.ts",
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b89887cafa0..55200b29676 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3123,8 +3123,8 @@ namespace ts {
         ContainsES2017 = 1 << 5,
         ES2016 = 1 << 6,
         ContainsES2016 = 1 << 7,
-        ES6 = 1 << 8,
-        ContainsES6 = 1 << 9,
+        ES2015 = 1 << 8,
+        ContainsES2015 = 1 << 9,
         DestructuringAssignment = 1 << 10,
         Generator = 1 << 11,
         ContainsGenerator = 1 << 12,
@@ -3153,13 +3153,13 @@ namespace ts {
         AssertJsx = Jsx | ContainsJsx,
         AssertES2017 = ES2017 | ContainsES2017,
         AssertES2016 = ES2016 | ContainsES2016,
-        AssertES6 = ES6 | ContainsES6,
+        AssertES2015 = ES2015 | ContainsES2015,
         AssertGenerator = Generator | ContainsGenerator,
 
         // Scope Exclusions
         // - Bitmasks that exclude flags from propagating out of a specific context
         //   into the subtree flags of their container.
-        NodeExcludes = TypeScript | Jsx | ES2017 | ES2016 | ES6 | DestructuringAssignment | Generator | HasComputedFlags,
+        NodeExcludes = TypeScript | Jsx | ES2017 | ES2016 | ES2015 | DestructuringAssignment | Generator | HasComputedFlags,
         ArrowFunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
         FunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsCapturedLexicalThis | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
         ConstructorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
@@ -3175,7 +3175,7 @@ namespace ts {
         // Masks
         // - Additional bitmasks
         TypeScriptClassSyntaxMask = ContainsParameterPropertyAssignments | ContainsPropertyInitializer | ContainsDecorators,
-        ES6FunctionSyntaxMask = ContainsCapturedLexicalThis | ContainsDefaultValueAssignments,
+        ES2015FunctionSyntaxMask = ContainsCapturedLexicalThis | ContainsDefaultValueAssignments,
     }
 
     /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 92ce6ecc6a4..e10ab6a8add 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -337,7 +337,7 @@ namespace ts {
     export function getLiteralText(node: LiteralLikeNode, sourceFile: SourceFile, languageVersion: ScriptTarget) {
         // Any template literal or string literal with an extended escape
         // (e.g. "\u{0067}") will need to be downleveled as a escaped string literal.
-        if (languageVersion < ScriptTarget.ES6 && (isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) {
+        if (languageVersion < ScriptTarget.ES2015 && (isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) {
             return getQuotedEscapedLiteralText('"', node.text, '"');
         }
 
@@ -345,7 +345,7 @@ namespace ts {
         // the node's parent reference, then simply get the text as it was originally written.
         if (!nodeIsSynthesized(node) && node.parent) {
             const text = getSourceTextOfNodeFromSourceFile(sourceFile, node);
-            if (languageVersion < ScriptTarget.ES6 && isBinaryOrOctalIntegerLiteral(node, text)) {
+            if (languageVersion < ScriptTarget.ES2015 && isBinaryOrOctalIntegerLiteral(node, text)) {
                 return node.text;
             }
             return text;
@@ -4146,7 +4146,7 @@ namespace ts {
                 return "lib.es2017.d.ts";
             case ScriptTarget.ES2016:
                 return "lib.es2016.d.ts";
-            case ScriptTarget.ES6:
+            case ScriptTarget.ES2015:
                 return "lib.es2015.d.ts";
 
             default:
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index c50f33a74c3..3b45d6d61e5 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -946,7 +946,7 @@ namespace Harness {
                     return "lib.es2017.d.ts";
                 case ts.ScriptTarget.ES2016:
                     return "lib.es2016.d.ts";
-                case ts.ScriptTarget.ES6:
+                case ts.ScriptTarget.ES2015:
                     return es2015DefaultLibFileName;
 
                 default:
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index c8b90645ce2..5d7a81d1a74 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -28,12 +28,12 @@
         "../compiler/transformers/jsx.ts",
         "../compiler/transformers/es2017.ts",
         "../compiler/transformers/es2016.ts",
-        "../compiler/transformers/es6.ts",
+        "../compiler/transformers/es2015.ts",
         "../compiler/transformers/generators.ts",
         "../compiler/transformers/destructuring.ts",
         "../compiler/transformers/module/module.ts",
         "../compiler/transformers/module/system.ts",
-        "../compiler/transformers/module/es6.ts",
+        "../compiler/transformers/module/es2015.ts",
         "../compiler/transformer.ts",
         "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
diff --git a/src/harness/unittests/moduleResolution.ts b/src/harness/unittests/moduleResolution.ts
index 3e1ac171216..b2f7d0c224d 100644
--- a/src/harness/unittests/moduleResolution.ts
+++ b/src/harness/unittests/moduleResolution.ts
@@ -1017,7 +1017,7 @@ import b = require("./moduleB");
             const files = [f1, f2, f3, f4];
 
             const names = map(files, f => f.name);
-            const sourceFiles = arrayToMap(map(files, f => createSourceFile(f.name, f.content, ScriptTarget.ES6)), f => f.fileName);
+            const sourceFiles = arrayToMap(map(files, f => createSourceFile(f.name, f.content, ScriptTarget.ES2015)), f => f.fileName);
             const compilerHost: CompilerHost = {
                 fileExists : fileName => fileName in sourceFiles,
                 getSourceFile: fileName => sourceFiles[fileName],
diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json
index 45e3c9036e0..c9428d9a082 100644
--- a/src/services/tsconfig.json
+++ b/src/services/tsconfig.json
@@ -27,12 +27,12 @@
         "../compiler/transformers/jsx.ts",
         "../compiler/transformers/es2017.ts",
         "../compiler/transformers/es2016.ts",
-        "../compiler/transformers/es6.ts",
+        "../compiler/transformers/es2015.ts",
         "../compiler/transformers/generators.ts",
         "../compiler/transformers/destructuring.ts",
         "../compiler/transformers/module/module.ts",
         "../compiler/transformers/module/system.ts",
-        "../compiler/transformers/module/es6.ts",
+        "../compiler/transformers/module/es2015.ts",
         "../compiler/transformer.ts",
         "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 829048fc081..e61906b4f09 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -1339,7 +1339,7 @@ namespace ts {
         const options: TranspileOptions = {
             fileName: "config.js",
             compilerOptions: {
-                target: ScriptTarget.ES6,
+                target: ScriptTarget.ES2015,
                 removeComments: true
             },
             reportDiagnostics: true