diff --git a/Jakefile.js b/Jakefile.js
index 252932ff511..15ad9c7be52 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -91,88 +91,7 @@ var languageServiceLibrarySources = filesFromConfig(path.join(serverDirectory, "
 
 var typesMapOutputPath = path.join(builtLocalDirectory, 'typesMap.json');
 
-var harnessCoreSources = [
-    "harness.ts",
-    "collections.ts",
-    "vpath.ts",
-    "events.ts",
-    "vfs.ts",
-    "virtualFileSystemWithWatch.ts",
-    "sourceMapRecorder.ts",
-    "harnessLanguageService.ts",
-    "fourslash.ts",
-    "runnerbase.ts",
-    "compilerRunner.ts",
-    "typeWriter.ts",
-    "fourslashRunner.ts",
-    "projectsRunner.ts",
-    "loggedIO.ts",
-    "rwcRunner.ts",
-    "userRunner.ts",
-    "test262Runner.ts",
-    "./parallel/shared.ts",
-    "./parallel/host.ts",
-    "./parallel/worker.ts",
-    "runner.ts"
-].map(function (f) {
-    return path.join(harnessDirectory, f);
-});
-
-var harnessSources = harnessCoreSources.concat([
-    "incrementalParser.ts",
-    "jsDocParsing.ts",
-    "services/colorization.ts",
-    "services/documentRegistry.ts",
-    "services/preProcessFile.ts",
-    "services/patternMatcher.ts",
-    "session.ts",
-    "versionCache.ts",
-    "convertToBase64.ts",
-    "transpile.ts",
-    "reuseProgramStructure.ts",
-    "textStorage.ts",
-    "moduleResolution.ts",
-    "tsconfigParsing.ts",
-    "builder.ts",
-    "commandLineParsing.ts",
-    "configurationExtension.ts",
-    "convertCompilerOptionsFromJson.ts",
-    "convertTypeAcquisitionFromJson.ts",
-    "tsserverProjectSystem.ts",
-    "tscWatchMode.ts",
-    "compileOnSave.ts",
-    "typingsInstaller.ts",
-    "projectErrors.ts",
-    "matchFiles.ts",
-    "initializeTSConfig.ts",
-    "extractConstants.ts",
-    "extractFunctions.ts",
-    "extractRanges.ts",
-    "extractTestHelpers.ts",
-    "printer.ts",
-    "textChanges.ts",
-    "telemetry.ts",
-    "transform.ts",
-    "customTransforms.ts",
-    "programMissingFiles.ts",
-    "symbolWalker.ts",
-    "languageService.ts",
-    "publicApi.ts",
-    "hostNewLineSupport.ts",
-].map(function (f) {
-    return path.join(unittestsDirectory, f);
-})).concat([
-    "protocol.ts",
-    "utilities.ts",
-    "scriptVersionCache.ts",
-    "scriptInfo.ts",
-    "project.ts",
-    "typingsCache.ts",
-    "editorServices.ts",
-    "session.ts",
-].map(function (f) {
-    return path.join(serverDirectory, f);
-}));
+var harnessSources = filesFromConfig("./src/harness/tsconfig.json");
 
 var es2015LibrarySources = [
     "es2015.core.d.ts",
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index f1322f109cc..64d6455e67a 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1749,7 +1749,7 @@ namespace ts {
     }
 
     function getDiagnosticFileName(diagnostic: Diagnostic): string {
-        return diagnostic.file ? diagnostic.file.fileName : undefined;
+        return diagnostic.file ? diagnostic.file.path : undefined;
     }
 
     export function compareDiagnostics(d1: Diagnostic, d2: Diagnostic): Comparison {
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 7a1d88d3bfd..32d778029f3 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -50,7 +50,8 @@ namespace ts {
     // JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.
     // So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.
     // For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve
-    function getOutputExtension(sourceFile: SourceFile, options: CompilerOptions): Extension {
+    /* @internal */
+    export function getOutputExtension(sourceFile: SourceFile, options: CompilerOptions): Extension {
         if (options.jsx === JsxEmit.Preserve) {
             if (isSourceFileJavaScript(sourceFile)) {
                 if (fileExtensionIs(sourceFile.fileName, Extension.Jsx)) {
diff --git a/src/harness/compiler.ts b/src/harness/compiler.ts
new file mode 100644
index 00000000000..c6f0f831f81
--- /dev/null
+++ b/src/harness/compiler.ts
@@ -0,0 +1,377 @@
+/// <reference path="./harness.ts" />
+/// <reference path="./documents.ts" />
+/// <reference path="./collections.ts" />
+/// <reference path="./vpath.ts" />
+/// <reference path="./vfs.ts" />
+/// <reference path="./utils.ts" />
+
+namespace compiler {
+    import TextDocument = documents.TextDocument;
+    import SourceMap = documents.SourceMap;
+    import KeyedCollection = collections.KeyedCollection;
+    import VirtualFileSystem = vfs.VirtualFileSystem;
+
+    export class CompilerHost {
+        public readonly vfs: vfs.VirtualFileSystem;
+        public readonly defaultLibLocation: string;
+        public readonly outputs: TextDocument[] = [];
+        public readonly traces: string[] = [];
+
+        private _setParentNodes: boolean;
+        private _sourceFiles: KeyedCollection<string, ts.SourceFile>;
+        private _newLine: string;
+        private _parseConfigHost: ParseConfigHost;
+
+        constructor(vfs: VirtualFileSystem, options: ts.CompilerOptions, setParentNodes = false) {
+            this.vfs = vfs;
+            this.defaultLibLocation = vfs.metadata.get("defaultLibLocation") || "";
+            this._sourceFiles = new KeyedCollection<string, ts.SourceFile>(this.vfs.pathComparer);
+            this._newLine = options.newLine === ts.NewLineKind.LineFeed ? "\n" : "\r\n";
+            this._setParentNodes = setParentNodes;
+        }
+
+        public get parseConfigHost() {
+            return this._parseConfigHost || (this._parseConfigHost = new ParseConfigHost(this.vfs));
+        }
+
+        public getCurrentDirectory(): string {
+            return this.vfs.currentDirectory;
+        }
+
+        public useCaseSensitiveFileNames(): boolean {
+            return this.vfs.useCaseSensitiveFileNames;
+        }
+
+        public getNewLine(): string {
+            return this._newLine;
+        }
+
+        public getCanonicalFileName(fileName: string): string {
+            return this.vfs.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+        }
+
+        public fileExists(fileName: string): boolean {
+            return this.vfs.fileExists(fileName);
+        }
+
+        public directoryExists(directoryName: string): boolean {
+            return this.vfs.directoryExists(directoryName);
+        }
+
+        public getDirectories(path: string): string[] {
+            const entry = this.vfs.getDirectory(path);
+            return entry ? entry.getDirectories().map(dir => dir.name) : [];
+        }
+
+        public readFile(path: string): string | undefined {
+            const entry = this.vfs.getFile(path);
+            const content = entry && entry.content && utils.removeByteOrderMark(entry.content);
+            return content === undefined ? undefined :
+                vpath.extname(path) === ".json" ? utils.removeComments(content, utils.CommentRemoval.leadingAndTrailing) :
+                content;
+        }
+
+        public writeFile(fileName: string, content: string, writeByteOrderMark: boolean) {
+            // NOTE(rbuckton): Old harness emits "\u00EF\u00BB\u00BF" for UTF8 BOM, but compiler emits "\uFEFF". Compiler is wrong, as "\uFEFF" is a UTF16 BOM.
+            if (writeByteOrderMark) content = "\u00EF\u00BB\u00BF" + content;
+            const entry = this.vfs.addFile(fileName, content, { overwrite: true });
+            if (entry) {
+                const document = new TextDocument(fileName, content);
+                document.meta.set("fileName", fileName);
+                entry.metadata.set("document", document);
+                const index = this.outputs.findIndex(output => this.vfs.pathComparer(document.file, output.file) === 0);
+                if (index < 0) {
+                    this.outputs.push(document);
+                }
+                else {
+                    this.outputs[index] = document;
+                }
+            }
+        }
+
+        public trace(s: string): void {
+            this.traces.push(s);
+        }
+
+        public realpath(path: string): string {
+            const entry = this.vfs.getEntry(path, { followSymlinks: true });
+            return entry && entry.path || path;
+        }
+
+        public getDefaultLibLocation(): string {
+            return vpath.resolve(this.vfs.currentDirectory, this.defaultLibLocation);
+        }
+
+        public getDefaultLibFileName(options: ts.CompilerOptions): string {
+            return vpath.resolve(this.getDefaultLibLocation(), ts.getDefaultLibFileName(options));
+        }
+
+        public getSourceFile(fileName: string, languageVersion: number): ts.SourceFile | undefined {
+            const canonicalFileName = this.getCanonicalFileName(vpath.resolve(this.vfs.currentDirectory, fileName));
+            const existing = this._sourceFiles.get(canonicalFileName);
+            if (existing) return existing;
+            const file = this.vfs.getFile(canonicalFileName);
+            if (file) {
+                let content = file.content;
+                if (content !== undefined) {
+                    content = utils.removeByteOrderMark(content);
+
+                    // We cache and reuse source files for files we know shouldn't change.
+                    const shouldCache = vpath.isDefaultLibrary(fileName) ||
+                        vpath.beneath("/.ts", file.path, !this.vfs.useCaseSensitiveFileNames) ||
+                        vpath.beneath("/.lib", file.path, !this.vfs.useCaseSensitiveFileNames);
+
+                    const cacheKey = shouldCache && `SourceFile[languageVersion=${languageVersion},setParentNodes=${this._setParentNodes}]`;
+                    if (cacheKey) {
+                        const sourceFileFromMetadata = file.metadata.get(cacheKey) as ts.SourceFile | undefined;
+                        if (sourceFileFromMetadata) {
+                            this._sourceFiles.set(canonicalFileName, sourceFileFromMetadata);
+                            return sourceFileFromMetadata;
+                        }
+                    }
+
+                    const parsed = ts.createSourceFile(fileName, content, languageVersion, this._setParentNodes);
+                    this._sourceFiles.set(canonicalFileName, parsed);
+
+                    if (cacheKey) {
+                        // store the cached source file on the unshadowed file.
+                        let rootFile = file;
+                        while (rootFile.shadowRoot) rootFile = rootFile.shadowRoot;
+                        rootFile.metadata.set(cacheKey, parsed);
+                    }
+
+                    return parsed;
+                }
+            }
+        }
+    }
+
+    export class ParseConfigHost {
+        public readonly vfs: VirtualFileSystem;
+
+        constructor(vfs: VirtualFileSystem) {
+            this.vfs = vfs;
+        }
+
+        public get useCaseSensitiveFileNames() {
+            return this.vfs.useCaseSensitiveFileNames;
+        }
+
+        public readDirectory(path: string, extensions: string[], excludes: string[], includes: string[], depth: number): string[] {
+            return ts.matchFiles(
+                path,
+                extensions,
+                excludes,
+                includes,
+                this.vfs.useCaseSensitiveFileNames,
+                this.vfs.currentDirectory,
+                depth,
+                path => this.vfs.getAccessibleFileSystemEntries(path));
+        }
+
+        public fileExists(path: string) {
+            return this.vfs.fileExists(path);
+        }
+
+        public readFile(path: string) {
+            return this.vfs.readFile(path);
+        }
+    }
+
+    export interface Project {
+        file: string;
+        config?: ts.ParsedCommandLine;
+        errors?: ts.Diagnostic[];
+    }
+
+    export function readProject(host: ParseConfigHost, project: string | undefined, existingOptions?: ts.CompilerOptions): Project | undefined {
+        if (project) {
+            project = host.vfs.stringComparer(vpath.basename(project), "tsconfig.json") === 0 ? project :
+                vpath.combine(project, "tsconfig.json");
+        }
+        else {
+            const dir = host.vfs.getDirectory(host.vfs.currentDirectory);
+            const projectFile = dir && dir.findFile("tsconfig.json", "ancestors-or-self");
+            project = projectFile && projectFile.path;
+        }
+
+        if (project) {
+            // TODO(rbuckton): Do we need to resolve this? Resolving breaks projects tests.
+            // project = vpath.resolve(host.vfs.currentDirectory, project);
+
+            // read the config file
+            const readResult = ts.readConfigFile(project, path => host.readFile(path));
+            if (readResult.error) {
+                return { file: project, errors: [readResult.error] };
+            }
+
+            // parse the config file
+            const config = ts.parseJsonConfigFileContent(readResult.config, host, vpath.dirname(project), existingOptions);
+            return { file: project, errors: config.errors, config };
+        }
+    }
+
+    export interface CompilationOutput {
+        readonly input: TextDocument;
+        readonly js: TextDocument | undefined;
+        readonly dts: TextDocument | undefined;
+        readonly map: TextDocument | undefined;
+    }
+
+    export class CompilationResult {
+        public readonly host: CompilerHost;
+        public readonly program: ts.Program | undefined;
+        public readonly result: ts.EmitResult | undefined;
+        public readonly options: ts.CompilerOptions;
+        public readonly diagnostics: ts.Diagnostic[];
+        public readonly js: KeyedCollection<string, TextDocument>;
+        public readonly dts: KeyedCollection<string, TextDocument>;
+        public readonly maps: KeyedCollection<string, TextDocument>;
+
+        private _inputs: TextDocument[] = [];
+        private _inputsAndOutputs: KeyedCollection<string, CompilationOutput>;
+
+        constructor(host: CompilerHost, options: ts.CompilerOptions, program: ts.Program | undefined, result: ts.EmitResult | undefined, diagnostics: ts.Diagnostic[]) {
+            this.host = host;
+            this.program = program;
+            this.result = result;
+            this.diagnostics = diagnostics;
+            this.options = program ? program.getCompilerOptions() : options;
+
+            // collect outputs
+            this.js = new KeyedCollection<string, TextDocument>(this.vfs.pathComparer);
+            this.dts = new KeyedCollection<string, TextDocument>(this.vfs.pathComparer);
+            this.maps = new KeyedCollection<string, TextDocument>(this.vfs.pathComparer);
+            for (const document of this.host.outputs) {
+                if (vpath.isJavaScript(document.file)) {
+                    this.js.set(document.file, document);
+                }
+                else if (vpath.isDeclaration(document.file)) {
+                    this.dts.set(document.file, document);
+                }
+                else if (vpath.isSourceMap(document.file)) {
+                    this.maps.set(document.file, document);
+                }
+            }
+
+            // correlate inputs and outputs
+            this._inputsAndOutputs = new KeyedCollection<string, CompilationOutput>(this.vfs.pathComparer);
+            if (program) {
+                for (const sourceFile of program.getSourceFiles()) {
+                    if (sourceFile) {
+                        const input = new TextDocument(sourceFile.fileName, sourceFile.text);
+                        this._inputs.push(input);
+                        if (!vpath.isDeclaration(sourceFile.fileName)) {
+                            const outputs = {
+                                input,
+                                js: this.js.get(this.getOutputPath(sourceFile.fileName, ts.getOutputExtension(sourceFile, this.options))),
+                                dts: this.dts.get(this.getOutputPath(sourceFile.fileName, ".d.ts", this.options.declarationDir)),
+                                map: this.maps.get(this.getOutputPath(sourceFile.fileName, ts.getOutputExtension(sourceFile, this.options) + ".map"))
+                            };
+
+                            this._inputsAndOutputs.set(sourceFile.fileName, outputs);
+                            if (outputs.js) this._inputsAndOutputs.set(outputs.js.file, outputs);
+                            if (outputs.dts) this._inputsAndOutputs.set(outputs.dts.file, outputs);
+                            if (outputs.map) this._inputsAndOutputs.set(outputs.map.file, outputs);
+                        }
+                    }
+                }
+            }
+        }
+
+        public get vfs() {
+            return this.host.vfs;
+        }
+
+        public get inputs(): ReadonlyArray<TextDocument> {
+            return this._inputs;
+        }
+
+        public get outputs(): ReadonlyArray<TextDocument> {
+            return this.host.outputs;
+        }
+
+        public get traces(): ReadonlyArray<string> {
+            return this.host.traces;
+        }
+
+        public get emitSkipped(): boolean {
+            return this.result && this.result.emitSkipped || false;
+        }
+
+        public get singleFile(): boolean {
+            return !!this.options.outFile || !!this.options.out;
+        }
+
+        public get commonSourceDirectory(): string {
+            const common = this.program && this.program.getCommonSourceDirectory() || "";
+            return common && vpath.combine(this.vfs.currentDirectory, common);
+        }
+
+        public getInputsAndOutputs(path: string): CompilationOutput | undefined {
+            return this._inputsAndOutputs.get(vpath.resolve(this.vfs.currentDirectory, path));
+        }
+
+        public getInput(path: string): TextDocument | undefined {
+            const outputs = this.getInputsAndOutputs(path);
+            return outputs && outputs.input;
+        }
+
+        public getOutput(path: string, kind: "js" | "dts" | "map"): TextDocument | undefined {
+            const outputs = this.getInputsAndOutputs(path);
+            return outputs && outputs[kind];
+        }
+
+        public getSourceMap(path: string): SourceMap | undefined {
+            if (this.options.noEmit || vpath.isDeclaration(path)) return undefined;
+            if (this.options.inlineSourceMap) {
+                const document = this.getOutput(path, "js");
+                return document && SourceMap.fromSource(document.text);
+            }
+            if (this.options.sourceMap) {
+                const document = this.getOutput(path, "map");
+                return document && new SourceMap(document.file, document.text);
+            }
+        }
+
+        public getOutputPath(path: string, ext: string, outDir: string | undefined = this.options.outDir) {
+            if (outDir) {
+                path = vpath.resolve(this.vfs.currentDirectory, path);
+                const common = this.commonSourceDirectory;
+                if (!common) return vpath.changeExtension(path, ext);
+                path = vpath.relative(common, path, !this.vfs.useCaseSensitiveFileNames);
+                path = vpath.combine(vpath.resolve(this.vfs.currentDirectory, outDir), path);
+                return vpath.changeExtension(path, ext);
+            }
+            const outFile = vpath.resolve(this.vfs.currentDirectory, this.options.outFile || this.options.out || path);
+            return vpath.changeExtension(outFile, ext);
+        }
+    }
+
+    export function compileFiles(host: CompilerHost, rootFiles: string[] | undefined, compilerOptions: ts.CompilerOptions) {
+        // establish defaults (aligns with old harness)
+        if (compilerOptions.project || !rootFiles || rootFiles.length === 0) {
+            const project = readProject(host.parseConfigHost, compilerOptions.project, compilerOptions);
+            if (project) {
+                if (project.errors && project.errors.length > 0) {
+                    return new CompilationResult(host, compilerOptions, /*program*/ undefined, /*result*/ undefined, project.errors);
+                }
+                if (project.config) {
+                    rootFiles = project.config.fileNames;
+                    compilerOptions = project.config.options;
+                }
+            }
+            delete compilerOptions.project;
+        }
+
+        if (compilerOptions.target === undefined) compilerOptions.target = ts.ScriptTarget.ES3;
+        if (compilerOptions.newLine === undefined) compilerOptions.newLine = ts.NewLineKind.CarriageReturnLineFeed;
+        if (compilerOptions.skipDefaultLibCheck === undefined) compilerOptions.skipDefaultLibCheck = true;
+        if (compilerOptions.noErrorTruncation === undefined) compilerOptions.noErrorTruncation = true;
+
+        const program = ts.createProgram(rootFiles || [], compilerOptions, host);
+        const emitResult = program.emit();
+        const errors = ts.getPreEmitDiagnostics(program);
+        return new CompilationResult(host, compilerOptions, program, emitResult, errors);
+    }
+}
\ No newline at end of file
diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts
index 30c5e47949f..d8f82abe4ec 100644
--- a/src/harness/compilerRunner.ts
+++ b/src/harness/compilerRunner.ts
@@ -1,6 +1,10 @@
 /// <reference path="harness.ts" />
 /// <reference path="runnerbase.ts" />
 /// <reference path="typeWriter.ts" />
+/// <reference path="./vpath.ts" />
+/// <reference path="./vfs.ts" />
+/// <reference path="./compiler.ts" />
+/// <reference path="./documents.ts" />
 
 const enum CompilerTestType {
     Conformance,
@@ -65,7 +69,7 @@ class CompilerBaselineRunner extends RunnerBase {
             let otherFiles: Harness.Compiler.TestFile[];
 
             before(() => {
-                justName = fileName.replace(/^.*[\\\/]/, ""); // strips the fileName from the path.
+                justName = vpath.basename(fileName);
                 const content = Harness.IO.readFile(fileName);
                 const rootDir = fileName.indexOf("conformance") === -1 ? "tests/cases/compiler/" : ts.getDirectoryPath(fileName) + "/";
                 const testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName, rootDir);
@@ -141,7 +145,7 @@ class CompilerBaselineRunner extends RunnerBase {
             it (`Correct module resolution tracing for ${fileName}`, () => {
                 if (options.traceResolution) {
                     Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".trace.json"), () => {
-                        return JSON.stringify(result.traceResults || [], undefined, 4);
+                        return utils.removeTestPathPrefixes(JSON.stringify(result.traceResults || [], undefined, 4));
                     });
                 }
             });
@@ -150,7 +154,7 @@ class CompilerBaselineRunner extends RunnerBase {
             it("Correct sourcemap content for " + fileName, () => {
                 if (options.sourceMap || options.inlineSourceMap) {
                     Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
-                        const record = result.getSourceMapRecord();
+                        const record = utils.removeTestPathPrefixes(result.getSourceMapRecord());
                         if ((options.noEmitOnError && result.errors.length !== 0) || record === undefined) {
                             // Because of the noEmitOnError option no files are created. We need to return null because baselining isn't required.
                             /* tslint:disable:no-null-keyword */
@@ -222,4 +226,4 @@ class CompilerBaselineRunner extends RunnerBase {
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/harness/documents.ts b/src/harness/documents.ts
new file mode 100644
index 00000000000..b460cc8393f
--- /dev/null
+++ b/src/harness/documents.ts
@@ -0,0 +1,169 @@
+/// <reference path="harness.ts" />
+
+namespace documents {
+    export class TextDocument {
+        public readonly meta: Map<string, string>;
+        public readonly file: string;
+        public readonly text: string;
+
+        private _lineStarts: number[] | undefined;
+
+        constructor(file: string, content: string, meta?: Map<string, string>) {
+            this.file = file;
+            this.text = content;
+            this.meta = meta || new Map<string, string>();
+        }
+
+        public get lineStarts(): number[] {
+            return this._lineStarts || (this._lineStarts = ts.computeLineStarts(this.text));
+        }
+    }
+
+    export interface RawSourceMap {
+        version: number;
+        file: string;
+        sourceRoot?: string;
+        sources: string[];
+        sourcesContent?: string[];
+        names: string[];
+        mappings: string;
+    }
+
+    export interface Mapping {
+        mappingIndex: number;
+        emittedLine: number;
+        emittedColumn: number;
+        sourceIndex: number;
+        sourceLine: number;
+        sourceColumn: number;
+        nameIndex?: number;
+    }
+
+    const mappingRegExp = /([A-Za-z0-9+/]+),?|(;)|./g;
+    const sourceMappingURLRegExp = /^\/\/[#@]\s*sourceMappingURL\s*=\s*(.*?)\s*$/mig;
+    const dataURLRegExp = /^data:application\/json;base64,([a-z0-9+/=]+)$/i;
+
+    export class SourceMap {
+        public readonly raw: RawSourceMap;
+        public readonly mapFile: string | undefined;
+        public readonly version: number;
+        public readonly file: string;
+        public readonly sourceRoot: string | undefined;
+        public readonly sources: ReadonlyArray<string> = [];
+        public readonly sourcesContent: ReadonlyArray<string> | undefined;
+        public readonly mappings: ReadonlyArray<Mapping> = [];
+        public readonly names: ReadonlyArray<string> | undefined;
+
+        private _emittedLineMappings: Mapping[][] = [];
+        private _sourceLineMappings: Mapping[][][] = [];
+
+        constructor(mapFile: string | undefined, data: string | RawSourceMap) {
+            this.raw = typeof data === "string" ? JSON.parse(data) as RawSourceMap : data;
+            this.mapFile = mapFile;
+            this.version = this.raw.version;
+            this.file = this.raw.file;
+            this.sourceRoot = this.raw.sourceRoot;
+            this.sources = this.raw.sources;
+            this.sourcesContent = this.raw.sourcesContent;
+            this.names = this.raw.names;
+
+            // populate mappings
+            const mappings: Mapping[] = [];
+            let emittedLine = 0;
+            let emittedColumn = 0;
+            let sourceIndex = 0;
+            let sourceLine = 0;
+            let sourceColumn = 0;
+            let nameIndex = 0;
+            let match: RegExpExecArray | null;
+            while (match = mappingRegExp.exec(this.raw.mappings)) {
+                if (match[1]) {
+                    const segment = decodeVLQ(match[1]);
+                    if (segment.length !== 1 && segment.length !== 4 && segment.length !== 5) {
+                        throw new Error("Invalid VLQ");
+                    }
+
+                    emittedColumn += segment[0];
+                    if (segment.length >= 4) {
+                        sourceIndex += segment[1];
+                        sourceLine += segment[2];
+                        sourceColumn += segment[3];
+                    }
+
+                    const mapping: Mapping = { mappingIndex: mappings.length, emittedLine, emittedColumn, sourceIndex, sourceLine, sourceColumn };
+                    if (segment.length === 5) {
+                        nameIndex += segment[4];
+                        mapping.nameIndex = nameIndex;
+                    }
+
+                    mappings.push(mapping);
+
+                    const mappingsForEmittedLine = this._emittedLineMappings[mapping.emittedLine] || (this._emittedLineMappings[mapping.emittedLine] = []);
+                    mappingsForEmittedLine.push(mapping);
+
+                    const mappingsForSource = this._sourceLineMappings[mapping.sourceIndex] || (this._sourceLineMappings[mapping.sourceIndex] = []);
+                    const mappingsForSourceLine = mappingsForSource[mapping.sourceLine] || (mappingsForSource[mapping.sourceLine] = []);
+                    mappingsForSourceLine.push(mapping);
+                }
+                else if (match[2]) {
+                    emittedLine++;
+                    emittedColumn = 0;
+                }
+                else {
+                    throw new Error(`Unrecognized character '${match[0]}'.`);
+                }
+            }
+
+            this.mappings = mappings;
+        }
+
+        public static getUrl(text: string) {
+            let match: RegExpExecArray | null;
+            let lastMatch: RegExpExecArray | undefined;
+            while (match = sourceMappingURLRegExp.exec(text)) {
+                lastMatch = match;
+            }
+            return lastMatch ? lastMatch[1] : undefined;
+        }
+
+        public static fromUrl(url: string) {
+            const match = dataURLRegExp.exec(url);
+            return match ? new SourceMap(/*mapFile*/ undefined, new Buffer(match[1], "base64").toString("utf8")) : undefined;
+        }
+
+        public static fromSource(text: string) {
+            const url = this.getUrl(text);
+            return url && this.fromUrl(url);
+        }
+
+        public getMappingsForEmittedLine(emittedLine: number): ReadonlyArray<Mapping> | undefined {
+            return this._emittedLineMappings[emittedLine];
+        }
+
+        public getMappingsForSourceLine(sourceIndex: number, sourceLine: number): ReadonlyArray<Mapping> | undefined {
+            const mappingsForSource = this._sourceLineMappings[sourceIndex];
+            return mappingsForSource && mappingsForSource[sourceLine];
+        }
+    }
+
+    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    export function decodeVLQ(text: string) {
+        const vlq: number[] = [];
+        let shift = 0;
+        let value = 0;
+        for (let i = 0; i < text.length; i++) {
+            const currentByte = base64Chars.indexOf(text.charAt(i));
+            value += (currentByte & 31) << shift;
+            if ((currentByte & 32) === 0) {
+                vlq.push(value & 1 ? -(value >>> 1) : value >>> 1);
+                shift = 0;
+                value = 0;
+            }
+            else {
+                shift += 5;
+            }
+        }
+        return vlq;
+    }
+}
\ No newline at end of file
diff --git a/src/harness/events.ts b/src/harness/events.ts
index 9443bad9dfe..684995d4250 100644
--- a/src/harness/events.ts
+++ b/src/harness/events.ts
@@ -10,11 +10,11 @@ namespace events {
 
     export interface EventEmitter {
         on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once: this["on"];
-        addListener: this["on"];
-        prependListener: this["on"];
-        prependOnceListener: this["on"];
-        removeListener: this["on"];
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         removeAllListeners(event?: string | symbol): this;
         setMaxListeners(n: number): this;
         getMaxListeners(): number;
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 415de60fb60..964662aaa3e 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -957,6 +957,10 @@ namespace Harness {
     }
 }
 
+if (Harness.IO.tryEnableSourceMapsForHost && /^development$/i.test(Harness.IO.getEnvironmentVariable("NODE_ENV"))) {
+    Harness.IO.tryEnableSourceMapsForHost();
+}
+
 namespace Harness {
     export const libFolder = "built/local/";
     const tcServicesFileName = ts.combinePaths(libFolder, Utils.getExecutionEnvironment() === Utils.ExecutionEnvironment.Browser ? "typescriptServicesInBrowserTest.js" : "typescriptServices.js");
@@ -1333,7 +1337,7 @@ namespace Harness {
             options.skipDefaultLibCheck = typeof options.skipDefaultLibCheck === "undefined" ? true : options.skipDefaultLibCheck;
 
             if (typeof currentDirectory === "undefined") {
-                currentDirectory = Harness.IO.getCurrentDirectory();
+                currentDirectory = "/.src";
             }
 
             // Parse settings
@@ -1345,56 +1349,44 @@ namespace Harness {
             }
 
             const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : Harness.IO.useCaseSensitiveFileNames();
-            const programFiles: TestFile[] = inputFiles.slice();
+            const programFileNames = inputFiles.map(file => file.unitName);
+
             // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
             // Treat them as library files, so include them in build, but not in baselines.
             if (options.includeBuiltFile) {
-                const builtFileName = ts.combinePaths(libFolder, options.includeBuiltFile);
-                const builtFile: TestFile = {
-                    unitName: builtFileName,
-                    content: normalizeLineEndings(IO.readFile(builtFileName), Harness.IO.newLine()),
-                };
-                programFiles.push(builtFile);
+                programFileNames.push(vpath.combine("/.ts/", options.includeBuiltFile));
             }
 
-            const fileOutputs: GeneratedFile[] = [];
-
             // Files from tests\lib that are requested by "@libFiles"
             if (options.libFiles) {
                 for (const fileName of options.libFiles.split(",")) {
-                    const libFileName = "tests/lib/" + fileName;
-                    // Content is undefined here because in createCompilerHost we will create sourceFile for the lib file and cache the result
-                    programFiles.push({ unitName: libFileName, content: undefined });
+                    programFileNames.push(vpath.combine("/.lib/", fileName));
                 }
             }
 
+            const compilation = compiler.compileFiles(
+                new compiler.CompilerHost(
+                    vfs.VirtualFileSystem.createFromTestFiles(
+                        { useCaseSensitiveFileNames, currentDirectory },
+                        inputFiles.concat(otherFiles),
+                        { overwrite: true }
+                    ),
+                    options
+                ),
+                programFileNames,
+                options);
 
-            const programFileNames = programFiles.map(file => file.unitName);
+            const fileOutputs = compilation.outputs ? compilation.outputs.map(output => (<GeneratedFile>{
+                fileName: output.file,
+                code: utils.removeByteOrderMark(output.text),
+                writeByteOrderMark: utils.getByteOrderMarkLength(output.text) > 0
+            })) : [];
 
-            const compilerHost = createCompilerHost(
-                programFiles.concat(otherFiles),
-                (fileName, code, writeByteOrderMark) => fileOutputs.push({ fileName, code, writeByteOrderMark }),
-                options.target,
-                useCaseSensitiveFileNames,
-                currentDirectory,
-                options.newLine,
-                options.libFiles);
-
-            let traceResults: string[];
-            if (options.traceResolution) {
-                traceResults = [];
-                compilerHost.trace = text => traceResults.push(text);
-            }
-            else {
-                compilerHost.directoryExists = () => true; // This only visibly affects resolution traces, so to save time we always return true where possible
-            }
-            const program = ts.createProgram(programFileNames, options, compilerHost);
-
-            const emitResult = program.emit();
-
-            const errors = ts.getPreEmitDiagnostics(program);
-
-            const result = new CompilerResult(fileOutputs, errors, program, Harness.IO.getCurrentDirectory(), emitResult.sourceMaps, traceResults);
+            const traceResults = compilation.traces && compilation.traces.slice();
+            const program = compilation.program;
+            const emitResult = compilation.result;
+            const errors = compilation.diagnostics;
+            const result = new CompilerResult(fileOutputs, errors, program, compilation.vfs.currentDirectory, emitResult.sourceMaps, traceResults);
             return { result, options };
         }
 
@@ -1479,14 +1471,6 @@ namespace Harness {
             return { declInputFiles, declOtherFiles, declResult: output.result };
         }
 
-        function normalizeLineEndings(text: string, lineEnding: string): string {
-            let normalized = text.replace(/\r\n?/g, "\n");
-            if (lineEnding !== "\n") {
-                normalized = normalized.replace(/\n/g, lineEnding);
-            }
-            return normalized;
-        }
-
         export function minimalDiagnosticsToString(diagnostics: ReadonlyArray<ts.Diagnostic>, pretty?: boolean) {
             const host = { getCanonicalFileName, getCurrentDirectory: () => "", getNewLine: () => Harness.IO.newLine() };
             return (pretty ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics)(diagnostics, host);
@@ -1524,7 +1508,7 @@ namespace Harness {
             function outputErrorText(error: ts.Diagnostic) {
                 const message = ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine());
 
-                const errLines = RunnerBase.removeFullPaths(message)
+                const errLines = utils.removeTestPathPrefixes(message)
                     .split("\n")
                     .map(s => s.length > 0 && s.charAt(s.length - 1) === "\r" ? s.substr(0, s.length - 1) : s)
                     .filter(s => s.length > 0)
@@ -1542,7 +1526,7 @@ namespace Harness {
                 }
             }
 
-            yield [diagnosticSummaryMarker, minimalDiagnosticsToString(diagnostics, pretty) + Harness.IO.newLine() + Harness.IO.newLine(), diagnostics.length];
+            yield [diagnosticSummaryMarker, utils.removeTestPathPrefixes(minimalDiagnosticsToString(diagnostics, pretty)) + Harness.IO.newLine() + Harness.IO.newLine(), diagnostics.length];
 
             // Report global errors
             const globalErrors = diagnostics.filter(err => !err.file);
@@ -1557,7 +1541,7 @@ namespace Harness {
                 // Filter down to the errors in the file
                 const fileErrors = diagnostics.filter(e => {
                     const errFn = e.file;
-                    return errFn && errFn.fileName === inputFile.unitName;
+                    return errFn && utils.removeTestPathPrefixes(errFn.fileName) === utils.removeTestPathPrefixes(inputFile.unitName);
                 });
 
 
@@ -1774,7 +1758,7 @@ namespace Harness {
                         }
                         typeLines += "\r\n";
                     }
-                    yield [checkDuplicatedFileName(unitName, dupeCase), typeLines];
+                    yield [checkDuplicatedFileName(unitName, dupeCase), utils.removeTestPathPrefixes(typeLines)];
                 }
             }
         }
@@ -1866,8 +1850,8 @@ namespace Harness {
         }
 
         function fileOutput(file: GeneratedFile, harnessSettings: Harness.TestCaseParser.CompilerSettings): string {
-            const fileName = harnessSettings.fullEmitPaths ? file.fileName : ts.getBaseFileName(file.fileName);
-            return "//// [" + fileName + "]\r\n" + getByteOrderMarkText(file) + file.code;
+            const fileName = harnessSettings.fullEmitPaths ? utils.removeTestPathPrefixes(file.fileName) : ts.getBaseFileName(file.fileName);
+            return "//// [" + fileName + "]\r\n" + getByteOrderMarkText(file) + utils.removeTestPathPrefixes(file.code);
         }
 
         export function collateOutputs(outputFiles: Harness.Compiler.GeneratedFile[]): string {
@@ -2325,7 +2309,8 @@ namespace Harness {
     }
 
     export function isBuiltFile(filePath: string): boolean {
-        return filePath.indexOf(Harness.libFolder) === 0;
+        return filePath.indexOf(Harness.libFolder) === 0 ||
+            filePath.indexOf("/.ts/") === 0;
     }
 
     export function getDefaultLibraryFile(io: Harness.IO): Harness.Compiler.TestFile {
diff --git a/src/harness/runner.ts b/src/harness/runner.ts
index b30fd1a44a5..eb0ed4e614b 100644
--- a/src/harness/runner.ts
+++ b/src/harness/runner.ts
@@ -66,10 +66,6 @@ function createRunner(kind: TestRunnerKind): RunnerBase {
     ts.Debug.fail(`Unknown runner kind ${kind}`);
 }
 
-if (Harness.IO.tryEnableSourceMapsForHost && /^development$/i.test(Harness.IO.getEnvironmentVariable("NODE_ENV"))) {
-    Harness.IO.tryEnableSourceMapsForHost();
-}
-
 // users can define tests to run in mytest.config that will override cmd line args, otherwise use cmd line args (test.config), otherwise no options
 
 const mytestconfigFileName = "mytest.config";
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index dfcc29fa1b7..26f60116009 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -82,6 +82,16 @@
         "../services/codefixes/disableJsDiagnostics.ts",
 
         "harness.ts",
+        
+        "utils.ts",
+        "events.ts",
+        "collections.ts",
+        "documents.ts",
+        "vpath.ts",
+        "vfs.ts",
+        "compiler.ts",
+        
+        "virtualFileSystemWithWatch.ts",
         "sourceMapRecorder.ts",
         "harnessLanguageService.ts",
         "fourslash.ts",
@@ -98,11 +108,6 @@
         "./parallel/host.ts",
         "./parallel/worker.ts",
         "runner.ts",
-        "collections.ts",
-        "vpath.ts",
-        "events.ts",
-        "vfs.ts",
-        "virtualFileSystemWithWatch.ts",
         "../server/protocol.ts",
         "../server/session.ts",
         "../server/client.ts",
diff --git a/src/harness/utils.ts b/src/harness/utils.ts
new file mode 100644
index 00000000000..79ab489304e
--- /dev/null
+++ b/src/harness/utils.ts
@@ -0,0 +1,51 @@
+namespace utils {
+    export function getByteOrderMarkLength(text: string) {
+        if (text.length >= 2) {
+            const ch0 = text.charCodeAt(0);
+            const ch1 = text.charCodeAt(1);
+            if ((ch0 === 0xff && ch1 === 0xfe) ||
+                (ch0 === 0xfe && ch1 === 0xff)) {
+                return 2;
+            }
+            if (text.length >= 3 && ch0 === 0xef && ch1 === 0xbb && text.charCodeAt(2) === 0xbf) {
+                return 3;
+            }
+        }
+        return 0;
+    }
+
+    export function removeByteOrderMark(text: string) {
+        const length = getByteOrderMarkLength(text);
+        return length ? text.slice(length) : text;
+    }
+
+    const leadingCommentRegExp = /^(\s*\/\*[^]*?\*\/\s*|\s*\/\/[^\r\n\u2028\u2029]*[\r\n\u2028\u2029]*)+/;
+    const trailingCommentRegExp = /(\s*\/\*[^]*?\*\/\s*|\s*\/\/[^\r\n\u2028\u2029]*[\r\n\u2028\u2029]*)+$/;
+    const leadingAndTrailingCommentRegExp = /^(\s*\/\*[^]*?\*\/\s*|\s*\/\/[^\r\n\u2028\u2029]*[\r\n\u2028\u2029]*)+|(\s*\/\*[^]*?\*\/\s*|\s*\/\/[^\r\n\u2028\u2029]*[\r\n\u2028\u2029]*)+$/g;
+    const allCommentRegExp = /(['"])(?:(?!\1).|\\[^])*\1|(\/\*[^]*?\*\/|\/\/[^\r\n\u2028\u2029]*[\r\n\u2028\u2029]*)/g;
+
+    export const enum CommentRemoval {
+        leading,
+        trailing,
+        leadingAndTrailing,
+        all
+    }
+
+    export function removeComments(text: string, removal: CommentRemoval) {
+        switch (removal) {
+            case CommentRemoval.leading:
+                return text.replace(leadingCommentRegExp, "");
+            case CommentRemoval.trailing:
+                return text.replace(trailingCommentRegExp, "");
+            case CommentRemoval.leadingAndTrailing:
+                return text.replace(leadingAndTrailingCommentRegExp, "");
+            case CommentRemoval.all:
+                return text.replace(allCommentRegExp, (match, quote) => quote ? match : "");
+        }
+    }
+
+    const testPathPrefixRegExp = /\/\.(ts|lib|src)\//g;
+    export function removeTestPathPrefixes(text: string) {
+        return text !== undefined ? text.replace(testPathPrefixRegExp, "") : undefined;
+    }
+}
\ No newline at end of file
diff --git a/src/harness/vfs.ts b/src/harness/vfs.ts
index 9dd7295db61..238cb65e059 100644
--- a/src/harness/vfs.ts
+++ b/src/harness/vfs.ts
@@ -7,7 +7,6 @@ namespace vfs {
     import KeyedCollection = collections.KeyedCollection;
     import Metadata = collections.Metadata;
     import EventEmitter = events.EventEmitter;
-    import IO = Harness.IO;
 
     export interface PathMappings {
         [path: string]: string;
@@ -58,7 +57,7 @@ namespace vfs {
         return new RegExp(pattern, ignoreCase ? "i" : "");
     }
 
-    export function createResolver(io: IO, map?: PathMappings): FileSystemResolver {
+    export function createResolver(io: Harness.IO, map?: PathMappings): FileSystemResolver {
         const mapper = createMapper(!io.useCaseSensitiveFileNames(), map);
         return {
             getEntries(dir) {
@@ -126,6 +125,7 @@ namespace vfs {
         private _watchedDirectories: KeyedCollection<string, DirectoryWatcherEntryArray> | undefined;
         private _stringComparer: ts.Comparer<string> | undefined;
         private _pathComparer: ts.Comparer<string> | undefined;
+        private _metadata: Metadata;
         private _onRootFileSystemChange: (path: string, change: FileSystemChange) => void;
 
         constructor(currentDirectory: string, useCaseSensitiveFileNames: boolean) {
@@ -154,6 +154,13 @@ namespace vfs {
             return this._shadowRoot;
         }
 
+        /**
+         * Gets metadata about this file system.
+         */
+        public get metadata(): Metadata {
+            return this._metadata || (this._metadata = new Metadata(this.shadowRoot ? this.shadowRoot.metadata : undefined));
+        }
+
         /**
          * Gets a value indicating whether to use case sensitive file names.
          */
@@ -183,28 +190,29 @@ namespace vfs {
         }
 
         /**
-         * Gets a virtual file system with the following entries:
+         * Gets a virtual file system with the following directories:
          *
          * | path   | physical/virtual      |
          * |:-------|:----------------------|
          * | /.ts   | physical: built/local |
          * | /.lib  | physical: tests/lib   |
-         * | /.test | virtual               |
+         * | /.src  | virtual               |
          */
-        public static getBuiltLocal(useCaseSensitiveFileNames: boolean = IO.useCaseSensitiveFileNames()): VirtualFileSystem {
+        public static getBuiltLocal(useCaseSensitiveFileNames: boolean = Harness.IO.useCaseSensitiveFileNames()): VirtualFileSystem {
             let vfs = useCaseSensitiveFileNames ? this._builtLocalCS : this._builtLocalCI;
             if (!vfs) {
                 vfs = this._builtLocal;
                 if (!vfs) {
-                    const resolver = createResolver(IO, {
+                    const resolver = createResolver(Harness.IO, {
                         "/.ts": __dirname,
                         "/.lib": vpath.resolve(__dirname, "../../tests/lib")
                     });
-                    vfs = new VirtualFileSystem("/", IO.useCaseSensitiveFileNames());
+                    vfs = new VirtualFileSystem("/", Harness.IO.useCaseSensitiveFileNames());
+                    vfs.metadata.set("defaultLibLocation", "/.ts");
                     vfs.addDirectory("/.ts", resolver);
                     vfs.addDirectory("/.lib", resolver);
-                    vfs.addDirectory("/.test");
-                    vfs.changeDirectory("/.test");
+                    vfs.addDirectory("/.src");
+                    vfs.changeDirectory("/.src");
                     vfs.makeReadOnly();
                     this._builtLocal = vfs;
                 }
@@ -220,6 +228,34 @@ namespace vfs {
             return vfs;
         }
 
+        public static createFromOptions(options: { useCaseSensitiveFileNames?: boolean, currentDirectory?: string }) {
+            const vfs = this.getBuiltLocal(options.useCaseSensitiveFileNames).shadow();
+            if (options.currentDirectory) {
+                vfs.addDirectory(options.currentDirectory);
+                vfs.changeDirectory(options.currentDirectory);
+            }
+            return vfs;
+        }
+
+        public static createFromTestFiles(options: { useCaseSensitiveFileNames?: boolean, currentDirectory?: string }, documents: Harness.Compiler.TestFile[], fileOptions?: { overwrite?: boolean }) {
+            const vfs = this.createFromOptions(options);
+            for (const document of documents) {
+                const file = vfs.addFile(document.unitName, document.content, fileOptions)!;
+                assert.isDefined(file, `Failed to add file: '${document.unitName}'`);
+                file.metadata.set("document", document);
+                // Add symlinks
+                const symlink = document.fileOptions && document.fileOptions.symlink;
+                if (file && symlink) {
+                    for (const link of symlink.split(",")) {
+                        const symlink = vfs.addSymlink(vpath.resolve(vfs.currentDirectory, link.trim()), file)!;
+                        assert.isDefined(symlink, `Failed to symlink: '${link}'`);
+                        symlink.metadata.set("document", document);
+                    }
+                }
+            }
+            return vfs;
+        }
+
         /**
          * Changes the current directory to the supplied path.
          */
@@ -529,8 +565,27 @@ namespace vfs {
     }
 
     export interface VirtualFileSystemEntry {
+        // #region Event "fileSystemChange"
         on(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
-        emit(event: "fileSystemChange", path: string, change: FileSystemChange): boolean;
+        once(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        addListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        removeListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        prependListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        prependOnceListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        emit(name: "fileSystemChange", path: string, change: FileSystemChange): boolean;
+        // #endregion Event "fileSystemChange"
+    }
+
+    export interface VirtualFileSystemEntry {
+        // #region Untyped events
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        // #endregion Untyped events
     }
 
     export abstract class VirtualFileSystemEntry extends VirtualFileSystemObject {
@@ -631,10 +686,39 @@ namespace vfs {
     }
 
     export interface VirtualDirectory {
+        // #region Event "fileSystemChange"
         on(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        once(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        addListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        removeListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        prependListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        prependOnceListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        emit(name: "fileSystemChange", path: string, change: FileSystemChange): boolean;
+        // #endregion Event "fileSystemChange"
+    }
+
+    export interface VirtualDirectory {
+        // #region Event "childAdded" | "childRemoved"
         on(event: "childAdded" | "childRemoved", listener: (child: VirtualEntry) => void): this;
-        emit(event: "fileSystemChange", path: string, change: FileSystemChange): boolean;
-        emit(event: "childAdded" | "childRemoved", child: VirtualEntry): boolean;
+        once(event: "childAdded" | "childRemoved", listener: (child: VirtualEntry) => void): this;
+        addListener(event: "childAdded" | "childRemoved", listener: (child: VirtualEntry) => void): this;
+        removeListener(event: "childAdded" | "childRemoved", listener: (child: VirtualEntry) => void): this;
+        prependListener(event: "childAdded" | "childRemoved", listener: (child: VirtualEntry) => void): this;
+        prependOnceListener(event: "childAdded" | "childRemoved", listener: (child: VirtualEntry) => void): this;
+        emit(name: "childAdded" | "childRemoved", child: VirtualEntry): boolean;
+        // #endregion Event "childAdded" | "childRemoved"
+    }
+
+    export interface VirtualDirectory {
+        // #region Untyped events
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        // #endregion Untyped events
     }
 
     export class VirtualDirectory extends VirtualFileSystemEntry {
@@ -1277,10 +1361,39 @@ namespace vfs {
     }
 
     export interface VirtualFile {
+        // #region Event "fileSystemChange"
         on(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        once(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        addListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        removeListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        prependListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        prependOnceListener(event: "fileSystemChange", listener: (path: string, change: FileSystemChange) => void): this;
+        emit(name: "fileSystemChange", path: string, change: FileSystemChange): boolean;
+        // #endregion Event "fileSystemChange"
+    }
+
+    export interface VirtualFile {
+            // #region Event "contentChanged"
         on(event: "contentChanged", listener: (entry: VirtualFile) => void): this;
-        emit(event: "fileSystemChange", path: string, change: FileSystemChange): boolean;
-        emit(event: "contentChanged", entry: VirtualFile): boolean;
+        once(event: "contentChanged", listener: (entry: VirtualFile) => void): this;
+        addListener(event: "contentChanged", listener: (entry: VirtualFile) => void): this;
+        removeListener(event: "contentChanged", listener: (entry: VirtualFile) => void): this;
+        prependListener(event: "contentChanged", listener: (entry: VirtualFile) => void): this;
+        prependOnceListener(event: "contentChanged", listener: (entry: VirtualFile) => void): this;
+        emit(name: "contentChanged", entry: VirtualFile): boolean;
+        // #endregion Event "contentChanged"
+    }
+
+    export interface VirtualFile {
+            // #region Untyped events
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        // #endregion Untyped events
     }
 
     export class VirtualFile extends VirtualFileSystemEntry {
diff --git a/src/harness/vpath.ts b/src/harness/vpath.ts
index fe6a6b36a12..7a7669a4e10 100644
--- a/src/harness/vpath.ts
+++ b/src/harness/vpath.ts
@@ -134,8 +134,6 @@ namespace vpath {
      * Compare two paths.
      */
     export function compare(a: string, b: string, ignoreCase: boolean) {
-        if (!isAbsolute(a)) throw new Error("Path not absolute");
-        if (!isAbsolute(b)) throw new Error("Path not absolute");
         if (a === b) return 0;
         a = removeTrailingSeparator(a);
         b = removeTrailingSeparator(b);
@@ -269,4 +267,38 @@ namespace vpath {
         const match = extRegExp.exec(path);
         return match ? match[0] : "";
     }
+
+    export function changeExtension(path: string, ext: string): string;
+    export function changeExtension(path: string, ext: string, extensions: string | string[], ignoreCase: boolean): string;
+    export function changeExtension(path: string, ext: string, extensions?: string | string[], ignoreCase?: boolean) {
+        const pathext = extensions ? extname(path, extensions, ignoreCase) : extname(path);
+        return pathext ? path.slice(0, path.length - pathext.length) + (ext.startsWith(".") ? ext : "." + ext) : path;
+    }
+
+    export function isTypeScript(path: string) {
+        return path.endsWith(".ts")
+            || path.endsWith(".tsx");
+    }
+
+    export function isJavaScript(path: string) {
+        return path.endsWith(".js")
+            || path.endsWith(".jsx");
+    }
+
+    export function isDeclaration(path: string) {
+        return path.endsWith(".d.ts");
+    }
+
+    export function isSourceMap(path: string) {
+        return path.endsWith(".map");
+    }
+
+    export function isJson(path: string) {
+        return path.endsWith(".json");
+    }
+
+    export function isDefaultLibrary(path: string) {
+        return isDeclaration(path)
+            && basename(path).startsWith("lib.");
+    }
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-of1.errors.txt b/tests/baselines/reference/ES5For-of1.errors.txt
deleted file mode 100644
index 16222725b3d..00000000000
--- a/tests/baselines/reference/ES5For-of1.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-of1.ts(2,5): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/conformance/statements/for-ofStatements/ES5For-of1.ts (1 errors) ====
-    for (var v of ['a', 'b', 'c']) {
-        console.log(v);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-of1.symbols b/tests/baselines/reference/ES5For-of1.symbols
index a80c69cd2cf..ded21109f38 100644
--- a/tests/baselines/reference/ES5For-of1.symbols
+++ b/tests/baselines/reference/ES5For-of1.symbols
@@ -3,5 +3,8 @@ for (var v of ['a', 'b', 'c']) {
 >v : Symbol(v, Decl(ES5For-of1.ts, 0, 8))
 
     console.log(v);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(ES5For-of1.ts, 0, 8))
 }
diff --git a/tests/baselines/reference/ES5For-of1.types b/tests/baselines/reference/ES5For-of1.types
index 4f9117740fb..cc6c94fcb57 100644
--- a/tests/baselines/reference/ES5For-of1.types
+++ b/tests/baselines/reference/ES5For-of1.types
@@ -7,9 +7,9 @@ for (var v of ['a', 'b', 'c']) {
 >'c' : "c"
 
     console.log(v);
->console.log(v) : any
->console.log : any
->console : any
->log : any
+>console.log(v) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >v : string
 }
diff --git a/tests/baselines/reference/ES5For-of22.errors.txt b/tests/baselines/reference/ES5For-of22.errors.txt
deleted file mode 100644
index 914be13c63c..00000000000
--- a/tests/baselines/reference/ES5For-of22.errors.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-of22.ts(3,5): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/conformance/statements/for-ofStatements/ES5For-of22.ts (1 errors) ====
-    for (var x of [1, 2, 3]) {
-        let _a = 0;
-        console.log(x);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-of22.symbols b/tests/baselines/reference/ES5For-of22.symbols
index 6511d8c9a8b..0aacdd6ca5d 100644
--- a/tests/baselines/reference/ES5For-of22.symbols
+++ b/tests/baselines/reference/ES5For-of22.symbols
@@ -6,5 +6,8 @@ for (var x of [1, 2, 3]) {
 >_a : Symbol(_a, Decl(ES5For-of22.ts, 1, 7))
 
     console.log(x);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(ES5For-of22.ts, 0, 8))
 }
diff --git a/tests/baselines/reference/ES5For-of22.types b/tests/baselines/reference/ES5For-of22.types
index ec99c310bf7..c4238551379 100644
--- a/tests/baselines/reference/ES5For-of22.types
+++ b/tests/baselines/reference/ES5For-of22.types
@@ -11,9 +11,9 @@ for (var x of [1, 2, 3]) {
 >0 : 0
 
     console.log(x);
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : number
 }
diff --git a/tests/baselines/reference/ES5For-of23.errors.txt b/tests/baselines/reference/ES5For-of23.errors.txt
deleted file mode 100644
index cbc043e32d2..00000000000
--- a/tests/baselines/reference/ES5For-of23.errors.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-of23.ts(3,5): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/conformance/statements/for-ofStatements/ES5For-of23.ts (1 errors) ====
-    for (var x of [1, 2, 3]) {
-        var _a = 0;
-        console.log(x);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-of23.symbols b/tests/baselines/reference/ES5For-of23.symbols
index 7b030d4e1e3..625b23dc7a8 100644
--- a/tests/baselines/reference/ES5For-of23.symbols
+++ b/tests/baselines/reference/ES5For-of23.symbols
@@ -6,5 +6,8 @@ for (var x of [1, 2, 3]) {
 >_a : Symbol(_a, Decl(ES5For-of23.ts, 1, 7))
 
     console.log(x);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(ES5For-of23.ts, 0, 8))
 }
diff --git a/tests/baselines/reference/ES5For-of23.types b/tests/baselines/reference/ES5For-of23.types
index c519e1c6ee2..4f90e492aac 100644
--- a/tests/baselines/reference/ES5For-of23.types
+++ b/tests/baselines/reference/ES5For-of23.types
@@ -11,9 +11,9 @@ for (var x of [1, 2, 3]) {
 >0 : 0
 
     console.log(x);
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : number
 }
diff --git a/tests/baselines/reference/ES5For-of33.errors.txt b/tests/baselines/reference/ES5For-of33.errors.txt
deleted file mode 100644
index 02ba889c542..00000000000
--- a/tests/baselines/reference/ES5For-of33.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts(2,5): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts (1 errors) ====
-    for (var v of ['a', 'b', 'c']) {
-        console.log(v);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-of33.symbols b/tests/baselines/reference/ES5For-of33.symbols
index 0d3008a5533..642afdc5368 100644
--- a/tests/baselines/reference/ES5For-of33.symbols
+++ b/tests/baselines/reference/ES5For-of33.symbols
@@ -3,5 +3,8 @@ for (var v of ['a', 'b', 'c']) {
 >v : Symbol(v, Decl(ES5For-of33.ts, 0, 8))
 
     console.log(v);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(ES5For-of33.ts, 0, 8))
 }
diff --git a/tests/baselines/reference/ES5For-of33.types b/tests/baselines/reference/ES5For-of33.types
index 2bcd7b9fc35..f7bfedb6909 100644
--- a/tests/baselines/reference/ES5For-of33.types
+++ b/tests/baselines/reference/ES5For-of33.types
@@ -7,9 +7,9 @@ for (var v of ['a', 'b', 'c']) {
 >'c' : "c"
 
     console.log(v);
->console.log(v) : any
->console.log : any
->console : any
->log : any
+>console.log(v) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >v : string
 }
diff --git a/tests/baselines/reference/anyAssignabilityInInheritance.symbols b/tests/baselines/reference/anyAssignabilityInInheritance.symbols
index 56bb982fea1..d0189b2c6aa 100644
--- a/tests/baselines/reference/anyAssignabilityInInheritance.symbols
+++ b/tests/baselines/reference/anyAssignabilityInInheritance.symbols
@@ -56,8 +56,8 @@ var r3 = foo3(a); // any
 declare function foo5(x: Date): Date;
 >foo5 : Symbol(foo5, Decl(anyAssignabilityInInheritance.ts, 19, 17), Decl(anyAssignabilityInInheritance.ts, 21, 37))
 >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 21, 22))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function foo5(x: any): any;
 >foo5 : Symbol(foo5, Decl(anyAssignabilityInInheritance.ts, 19, 17), Decl(anyAssignabilityInInheritance.ts, 21, 37))
diff --git a/tests/baselines/reference/anyAssignableToEveryType.symbols b/tests/baselines/reference/anyAssignableToEveryType.symbols
index 4995a24a5c2..7abc48548b8 100644
--- a/tests/baselines/reference/anyAssignableToEveryType.symbols
+++ b/tests/baselines/reference/anyAssignableToEveryType.symbols
@@ -44,7 +44,7 @@ var d: boolean = a;
 
 var e: Date = a;
 >e : Symbol(e, Decl(anyAssignableToEveryType.ts, 17, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3))
 
 var f: any = a;
@@ -122,7 +122,7 @@ function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(anyAssignableToEveryType.ts, 34, 13))
 >U : Symbol(U, Decl(anyAssignableToEveryType.ts, 34, 15))
 >V : Symbol(V, Decl(anyAssignableToEveryType.ts, 34, 32))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(anyAssignableToEveryType.ts, 34, 49))
 >T : Symbol(T, Decl(anyAssignableToEveryType.ts, 34, 13))
 >y : Symbol(y, Decl(anyAssignableToEveryType.ts, 34, 54))
diff --git a/tests/baselines/reference/anyAssignableToEveryType2.symbols b/tests/baselines/reference/anyAssignableToEveryType2.symbols
index 12d380aa368..75c6c1e170a 100644
--- a/tests/baselines/reference/anyAssignableToEveryType2.symbols
+++ b/tests/baselines/reference/anyAssignableToEveryType2.symbols
@@ -50,7 +50,7 @@ interface I5 {
 
     [x: string]: Date;
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 27, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: any;
 >foo : Symbol(I5.foo, Decl(anyAssignableToEveryType2.ts, 27, 22))
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
index aaa7431408b..d2b53d381e4 100644
--- a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
@@ -13,9 +13,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 >arguments : Symbol(arguments)
 
         result.push(arg + arg);
->result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>result.push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 1, 7))
->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12))
 >arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 2, 12))
     }
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
index 64b82088e1a..9582ff46bcf 100644
--- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
@@ -8,9 +8,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
     let blah = arguments[Symbol.iterator];
 >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 1, 7))
 >arguments : Symbol(arguments)
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     let result = [];
 >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7))
@@ -20,9 +20,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 1, 7))
 
         result.push(arg + arg);
->result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>result.push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 3, 7))
->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12))
 >arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 4, 12))
     }
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index da256ba2238..d11c61e5378 100644
--- a/tests/baselines/reference/arrayLiterals2ES6.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES6.symbols
@@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))
diff --git a/tests/baselines/reference/arrowFunctionContexts.errors.txt b/tests/baselines/reference/arrowFunctionContexts.errors.txt
index df158dec25e..b0d5d1dfc25 100644
--- a/tests/baselines/reference/arrowFunctionContexts.errors.txt
+++ b/tests/baselines/reference/arrowFunctionContexts.errors.txt
@@ -1,22 +1,16 @@
 tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(2,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
-tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(2,7): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(18,1): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(30,9): error TS2322: Type '() => number' is not assignable to type 'E'.
 tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(31,16): error TS2332: 'this' cannot be referenced in current location.
 tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(43,5): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
-tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(43,11): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(59,5): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(71,13): error TS2322: Type '() => number' is not assignable to type 'E'.
 tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,20): error TS2332: 'this' cannot be referenced in current location.
 
 
-==== tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts (10 errors) ====
+==== tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts (6 errors) ====
     // Arrow function used in with statement
     with (window) {
     ~~~~~~~~~~~~~
 !!! error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
-          ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
         var p = () => this;
     }
     
@@ -33,8 +27,6 @@ tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,20): e
     
     // Arrow function as function argument
     window.setTimeout(() => null, 100);
-    ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     
     // Arrow function as value in array literal
     
@@ -66,8 +58,6 @@ tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,20): e
         with (window) {
         ~~~~~~~~~~~~~
 !!! error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
-              ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
             var p = () => this;
         }
     
@@ -84,8 +74,6 @@ tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts(72,20): e
     
         // Arrow function as function argument
         window.setTimeout(() => null, 100);
-        ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     
         // Arrow function as value in array literal
     
diff --git a/tests/baselines/reference/arrowFunctionContexts.symbols b/tests/baselines/reference/arrowFunctionContexts.symbols
index 44b9aaedec4..b93929dee59 100644
--- a/tests/baselines/reference/arrowFunctionContexts.symbols
+++ b/tests/baselines/reference/arrowFunctionContexts.symbols
@@ -1,6 +1,8 @@
 === tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts ===
 // Arrow function used in with statement
 with (window) {
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+
     var p = () => this;
 }
 
@@ -25,6 +27,9 @@ class Derived extends Base {
 
 // Arrow function as function argument
 window.setTimeout(() => null, 100);
+>window.setTimeout : Symbol(WindowTimers.setTimeout, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>setTimeout : Symbol(WindowTimers.setTimeout, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Arrow function as value in array literal
 
@@ -77,6 +82,8 @@ module M2 {
 
     // Arrow function used in with statement
     with (window) {
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+
         var p = () => this;
     }
 
@@ -101,6 +108,9 @@ module M2 {
 
     // Arrow function as function argument
     window.setTimeout(() => null, 100);
+>window.setTimeout : Symbol(WindowTimers.setTimeout, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>setTimeout : Symbol(WindowTimers.setTimeout, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     // Arrow function as value in array literal
 
diff --git a/tests/baselines/reference/arrowFunctionContexts.types b/tests/baselines/reference/arrowFunctionContexts.types
index 80c310a8cd4..bd40854d948 100644
--- a/tests/baselines/reference/arrowFunctionContexts.types
+++ b/tests/baselines/reference/arrowFunctionContexts.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts ===
 // Arrow function used in with statement
 with (window) {
->window : any
+>window : Window
 
     var p = () => this;
 >p : any
@@ -32,10 +32,10 @@ class Derived extends Base {
 
 // Arrow function as function argument
 window.setTimeout(() => null, 100);
->window.setTimeout(() => null, 100) : any
->window.setTimeout : any
->window : any
->setTimeout : any
+>window.setTimeout(() => null, 100) : number
+>window.setTimeout : { (handler: (...args: any[]) => void, timeout: number): number; (handler: any, timeout?: any, ...args: any[]): number; }
+>window : Window
+>setTimeout : { (handler: (...args: any[]) => void, timeout: number): number; (handler: any, timeout?: any, ...args: any[]): number; }
 >() => null : () => any
 >null : null
 >100 : 100
@@ -104,7 +104,7 @@ module M2 {
 
     // Arrow function used in with statement
     with (window) {
->window : any
+>window : Window
 
         var p = () => this;
 >p : any
@@ -135,10 +135,10 @@ module M2 {
 
     // Arrow function as function argument
     window.setTimeout(() => null, 100);
->window.setTimeout(() => null, 100) : any
->window.setTimeout : any
->window : any
->setTimeout : any
+>window.setTimeout(() => null, 100) : number
+>window.setTimeout : { (handler: (...args: any[]) => void, timeout: number): number; (handler: any, timeout?: any, ...args: any[]): number; }
+>window : Window
+>setTimeout : { (handler: (...args: any[]) => void, timeout: number): number; (handler: any, timeout?: any, ...args: any[]): number; }
 >() => null : () => any
 >null : null
 >100 : 100
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
index 534f9cc1ea0..e435aae68e0 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
@@ -1,13 +1,13 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody6.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 3))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 3))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 36))
 
@@ -18,7 +18,7 @@ var c = () => ({ name: "foo", message: "bar" });
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 3))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 38))
 
diff --git a/tests/baselines/reference/asOperator1.symbols b/tests/baselines/reference/asOperator1.symbols
index 83813d26981..4fa95489ea9 100644
--- a/tests/baselines/reference/asOperator1.symbols
+++ b/tests/baselines/reference/asOperator1.symbols
@@ -13,7 +13,7 @@ var y = (null as string).length;
 
 var z = Date as any as string;
 >z : Symbol(z, Decl(asOperator1.ts, 3, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string'
 var j = 32 as number|string;
diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols b/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols
index de0a5dc7b28..341ded501dc 100644
--- a/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols
+++ b/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols
@@ -189,8 +189,8 @@ var a18: {
 
         (a: Date): Date;
 >a : Symbol(a, Decl(assignmentCompatWithCallSignatures3.ts, 40, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }
diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols
index 0e3b0b38332..7e7d1c96476 100644
--- a/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols
+++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols
@@ -189,8 +189,8 @@ var a18: {
 
         new (a: Date): Date;
 >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures3.ts, 40, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }
diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.symbols b/tests/baselines/reference/asyncAliasReturnType_es6.symbols
index c9c279dcc41..775a80846f9 100644
--- a/tests/baselines/reference/asyncAliasReturnType_es6.symbols
+++ b/tests/baselines/reference/asyncAliasReturnType_es6.symbols
@@ -2,7 +2,7 @@
 type PromiseAlias<T> = Promise<T>;
 >PromiseAlias : Symbol(PromiseAlias, Decl(asyncAliasReturnType_es6.ts, 0, 0))
 >T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
 
 async function f(): PromiseAlias<void> {
diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.symbols b/tests/baselines/reference/asyncArrowFunction10_es6.symbols
index 7962e8328bc..efdfdac1819 100644
--- a/tests/baselines/reference/asyncArrowFunction10_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction10_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts ===
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction10_es6.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
    // Legal to use 'await' in a type context.
    var v: await;
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
index 81cc2d29593..17d4cb12bcb 100644
--- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts ===
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
index b3cb60c95ca..3c27076ab65 100644
--- a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,11): error TS2304: Cannot find name 'async'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,18): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,24): error TS1005: ',' expected.
-tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,26): error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es2015.promise.d.ts 222:12, but here has type 'void'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,26): error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es6.d.ts 5438:12, but here has type 'void'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,33): error TS1005: '=' expected.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(1,40): error TS1109: Expression expected.
 
@@ -15,7 +15,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(
                            ~
 !!! error TS1005: ',' expected.
                              ~~~~~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es2015.promise.d.ts 222:12, but here has type 'void'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es6.d.ts 5438:12, but here has type 'void'.
                                     ~
 !!! error TS1005: '=' expected.
                                            ~~
diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.symbols b/tests/baselines/reference/asyncArrowFunction5_es6.symbols
index 44827a41f9b..39783cd3698 100644
--- a/tests/baselines/reference/asyncArrowFunction5_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction5_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts ===
 var foo = async (await): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction5_es6.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(asyncArrowFunction5_es6.ts, 0, 24))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(asyncArrowFunction5_es6.ts, 0, 24))
 }
diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.symbols b/tests/baselines/reference/asyncArrowFunction6_es6.symbols
index e3fa9a191f0..b7ba4d6d32e 100644
--- a/tests/baselines/reference/asyncArrowFunction6_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction6_es6.symbols
@@ -2,5 +2,5 @@
 var foo = async (a = await): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction6_es6.ts, 0, 3))
 >a : Symbol(a, Decl(asyncArrowFunction6_es6.ts, 0, 17))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.symbols b/tests/baselines/reference/asyncArrowFunction7_es6.symbols
index c2d9d8404da..5884d07b142 100644
--- a/tests/baselines/reference/asyncArrowFunction7_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction7_es6.symbols
@@ -1,12 +1,12 @@
 === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts ===
 var bar = async (): Promise<void> => {
 >bar : Symbol(bar, Decl(asyncArrowFunction7_es6.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
   // 'await' here is an identifier, and not an await expression.
   var foo = async (a = await): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction7_es6.ts, 2, 5))
 >a : Symbol(a, Decl(asyncArrowFunction7_es6.ts, 2, 19))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
   }
 }
diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.symbols b/tests/baselines/reference/asyncArrowFunction8_es6.symbols
index 47117f2c61c..572783c3107 100644
--- a/tests/baselines/reference/asyncArrowFunction8_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction8_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts ===
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction8_es6.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
   var v = { [await]: foo }
 >v : Symbol(v, Decl(asyncArrowFunction8_es6.ts, 1, 5))
diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
index 8d974d75dd3..b717aab314c 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,11): error TS2304: Cannot find name 'async'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,18): error TS2304: Cannot find name 'a'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,37): error TS1005: ',' expected.
-tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,39): error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es2015.promise.d.ts 222:12, but here has type 'void'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,39): error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es6.d.ts 5438:12, but here has type 'void'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,46): error TS1005: '=' expected.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,53): error TS1109: Expression expected.
 
@@ -15,7 +15,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(
                                         ~
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es2015.promise.d.ts 222:12, but here has type 'void'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' has type 'PromiseConstructor' at lib.es6.d.ts 5438:12, but here has type 'void'.
                                                  ~
 !!! error TS1005: '=' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols
index 6d0506402bb..7568151c758 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction9_es6.symbols
@@ -3,5 +3,5 @@ var foo = async (a = await => await): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction9_es6.ts, 0, 3))
 >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20))
 >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(asyncArrowFunction9_es6.ts, 0, 37))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(asyncArrowFunction9_es6.ts, 0, 37))
 }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols
index 4b312fd4646..14b989dda61 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols
@@ -10,9 +10,9 @@ class C {
 
       var fn = async () => await other.apply(this, arguments);      
 >fn : Symbol(fn, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 3, 9))
->other.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>other.apply : Symbol(Function.apply, Decl(lib.es6.d.ts, --, --))
 >other : Symbol(other, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 1, 13))
->apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>apply : Symbol(Function.apply, Decl(lib.es6.d.ts, --, --))
 >this : Symbol(C, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 0, 0))
 >arguments : Symbol(arguments)
    }
diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols
index 2d1808b8b8b..87ee54146bf 100644
--- a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols
+++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols
@@ -4,7 +4,7 @@ import { MyPromise } from "missing";
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwaitIsolatedModules_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es6.ts, 3, 11))
@@ -15,7 +15,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es6.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwaitIsolatedModules_es6.ts, 6, 38))
@@ -26,7 +26,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwaitIsolatedModules_es6.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwaitIsolatedModules_es6.ts, 11, 3))
@@ -37,7 +37,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwaitIsolatedModules_es6.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwaitIsolatedModules_es6.ts, 15, 3))
@@ -53,7 +53,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwaitIsolatedModules_es6.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es6.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -69,7 +69,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwaitIsolatedModules_es6.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwaitIsolatedModules_es6.ts, 23, 31))
@@ -85,7 +85,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(C.m2, Decl(asyncAwaitIsolatedModules_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.m3, Decl(asyncAwaitIsolatedModules_es6.ts, 29, 30))
@@ -96,7 +96,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwaitIsolatedModules_es6.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwaitIsolatedModules_es6.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncAwait_es6.symbols b/tests/baselines/reference/asyncAwait_es6.symbols
index 9093fc69064..dafaed09fda 100644
--- a/tests/baselines/reference/asyncAwait_es6.symbols
+++ b/tests/baselines/reference/asyncAwait_es6.symbols
@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(C.m2, Decl(asyncAwait_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.m3, Decl(asyncAwait_es6.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncDeclare_es6.symbols b/tests/baselines/reference/asyncDeclare_es6.symbols
index 85ea6c9f905..5332b7e93f4 100644
--- a/tests/baselines/reference/asyncDeclare_es6.symbols
+++ b/tests/baselines/reference/asyncDeclare_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/asyncDeclare_es6.ts ===
 declare async function foo(): Promise<void>;
 >foo : Symbol(foo, Decl(asyncDeclare_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols
index cbfb1bbf88d..f0422211366 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols
@@ -2,5 +2,5 @@
 async function foo(a = await => await): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration10_es6.ts, 0, 0))
 >a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
index 2ebbad8ca08..4c06d15bd60 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols
index f8adf060dc9..89e42800cd7 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols
@@ -2,5 +2,5 @@
 var v = async function await(): Promise<void> { }
 >v : Symbol(v, Decl(asyncFunctionDeclaration12_es6.ts, 0, 3))
 >await : Symbol(await, Decl(asyncFunctionDeclaration12_es6.ts, 0, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols
index 05d7c586cab..65227cf510c 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration13_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
    // Legal to use 'await' in a type context.
    var v: await;
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
index 89c9913c1cc..767125e903b 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
   return;
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols
index daf0d23a7e8..f78e25f1cac 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols
@@ -28,7 +28,7 @@ async function fn4(): number { } // error
 
 async function fn5(): PromiseLike<void> { } // error
 >fn5 : Symbol(fn5, Decl(asyncFunctionDeclaration15_es6.ts, 7, 32))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es6.d.ts, --, --))
 
 async function fn6(): Thenable { } // error
 >fn6 : Symbol(fn6, Decl(asyncFunctionDeclaration15_es6.ts, 8, 43))
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
index e8f03e0b55b..233600bb30d 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols
index 61f040d2834..e80dcb9224e 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts ===
 async function foo(await): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration5_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols
index e9e5f97ee0e..e9eada98ecb 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols
@@ -2,5 +2,5 @@
 async function foo(a = await): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration6_es6.ts, 0, 0))
 >a : Symbol(a, Decl(asyncFunctionDeclaration6_es6.ts, 0, 19))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols
index 67b117d59f8..697273a68db 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols
@@ -1,12 +1,12 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts ===
 async function bar(): Promise<void> {
 >bar : Symbol(bar, Decl(asyncFunctionDeclaration7_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
   // 'await' here is an identifier, and not a yield expression.
   async function foo(a = await): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration7_es6.ts, 0, 37))
 >a : Symbol(a, Decl(asyncFunctionDeclaration7_es6.ts, 2, 21))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
   }
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols
index 9d46d6f6d8f..862559ded73 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
   var v = { [await]: foo }
 >v : Symbol(v, Decl(asyncFunctionDeclaration9_es6.ts, 1, 5))
diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt b/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt
index 5d4a87a186c..9155606c99f 100644
--- a/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt
+++ b/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt
@@ -1,16 +1,13 @@
 error TS2468: Cannot find global value 'Promise'.
 tests/cases/compiler/asyncFunctionNoReturnType.ts(1,1): error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
-tests/cases/compiler/asyncFunctionNoReturnType.ts(2,9): error TS2304: Cannot find name 'window'.
 
 
 !!! error TS2468: Cannot find global value 'Promise'.
-==== tests/cases/compiler/asyncFunctionNoReturnType.ts (2 errors) ====
+==== tests/cases/compiler/asyncFunctionNoReturnType.ts (1 errors) ====
     async () => {
     ~~~~~~~~~~~~~
 !!! error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
         if (window)
-            ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
             return;
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.symbols b/tests/baselines/reference/asyncFunctionNoReturnType.symbols
index da7167599c9..c3b1f385f0d 100644
--- a/tests/baselines/reference/asyncFunctionNoReturnType.symbols
+++ b/tests/baselines/reference/asyncFunctionNoReturnType.symbols
@@ -1,7 +1,8 @@
 === tests/cases/compiler/asyncFunctionNoReturnType.ts ===
 async () => {
-No type information for this code.    if (window)
-No type information for this code.        return;
-No type information for this code.}
-No type information for this code.
-No type information for this code.
\ No newline at end of file
+    if (window)
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+
+        return;
+}
+
diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.types b/tests/baselines/reference/asyncFunctionNoReturnType.types
index 48f8b33c39d..16cf2aa578a 100644
--- a/tests/baselines/reference/asyncFunctionNoReturnType.types
+++ b/tests/baselines/reference/asyncFunctionNoReturnType.types
@@ -3,7 +3,7 @@ async () => {
 >async () => {    if (window)        return;} : () => Promise<void>
 
     if (window)
->window : any
+>window : Window
 
         return;
 }
diff --git a/tests/baselines/reference/asyncFunctionReturnType.symbols b/tests/baselines/reference/asyncFunctionReturnType.symbols
index ea0df55fb89..314e8c39490 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.symbols
+++ b/tests/baselines/reference/asyncFunctionReturnType.symbols
@@ -8,7 +8,7 @@ async function fAsync() {
 
 async function fAsyncExplicit(): Promise<[number, boolean]> {
 >fAsyncExplicit : Symbol(fAsyncExplicit, Decl(asyncFunctionReturnType.ts, 3, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     // This is contextually typed as a tuple.
     return [1, true];
@@ -29,7 +29,7 @@ async function fIndexedTypeForStringProp(obj: Obj): Promise<Obj["stringProp"]> {
 >fIndexedTypeForStringProp : Symbol(fIndexedTypeForStringProp, Decl(asyncFunctionReturnType.ts, 14, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 16, 41))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return obj.stringProp;
@@ -42,13 +42,13 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 >fIndexedTypeForPromiseOfStringProp : Symbol(fIndexedTypeForPromiseOfStringProp, Decl(asyncFunctionReturnType.ts, 18, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
 >stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -58,13 +58,13 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 >fIndexedTypeForExplicitPromiseOfStringProp : Symbol(fIndexedTypeForExplicitPromiseOfStringProp, Decl(asyncFunctionReturnType.ts, 22, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 24, 58))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 24, 58))
@@ -75,7 +75,7 @@ async function fIndexedTypeForAnyProp(obj: Obj): Promise<Obj["anyProp"]> {
 >fIndexedTypeForAnyProp : Symbol(fIndexedTypeForAnyProp, Decl(asyncFunctionReturnType.ts, 26, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 28, 38))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return obj.anyProp;
@@ -88,13 +88,13 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 >fIndexedTypeForPromiseOfAnyProp : Symbol(fIndexedTypeForPromiseOfAnyProp, Decl(asyncFunctionReturnType.ts, 30, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
 >anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -104,13 +104,13 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 >fIndexedTypeForExplicitPromiseOfAnyProp : Symbol(fIndexedTypeForExplicitPromiseOfAnyProp, Decl(asyncFunctionReturnType.ts, 34, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 36, 55))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 36, 55))
@@ -123,7 +123,7 @@ async function fGenericIndexedTypeForStringProp<TObj extends Obj>(obj: TObj): Pr
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 40, 66))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 40, 48))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 40, 48))
 
     return obj.stringProp;
@@ -138,13 +138,13 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
 
     return Promise.resolve(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
 >stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -156,13 +156,13 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 48, 83))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 48, 83))
@@ -175,7 +175,7 @@ async function fGenericIndexedTypeForAnyProp<TObj extends Obj>(obj: TObj): Promi
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 52, 63))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 52, 45))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 52, 45))
 
     return obj.anyProp;
@@ -190,13 +190,13 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
 
     return Promise.resolve(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
 >anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -208,13 +208,13 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 60, 80))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 60, 80))
@@ -231,7 +231,7 @@ async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TOb
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 64, 93))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
 
@@ -250,14 +250,14 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
 
     return Promise.resolve(obj[key]);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 68, 92))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
 }
@@ -272,14 +272,14 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 72, 110))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
 
     return Promise.resolve<TObj[K]>(obj[key]);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 72, 100))
diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols
index f6c8862e100..a6d0e0716d8 100644
--- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols
+++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols
@@ -105,7 +105,7 @@ declare function resolve1<T>(value: T): Promise<T>;
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26))
 >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 29))
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26))
 
 declare function resolve2<T>(value: T): Windows.Foundation.IPromise<T>;
diff --git a/tests/baselines/reference/asyncIIFE.symbols b/tests/baselines/reference/asyncIIFE.symbols
index ab7f297379e..b92404dadab 100644
--- a/tests/baselines/reference/asyncIIFE.symbols
+++ b/tests/baselines/reference/asyncIIFE.symbols
@@ -5,7 +5,7 @@ function f1() {
     (async () => {
         await 10
         throw new Error();
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     })();
 
diff --git a/tests/baselines/reference/asyncImportedPromise_es6.symbols b/tests/baselines/reference/asyncImportedPromise_es6.symbols
index 86f037946e2..b9a69b0570f 100644
--- a/tests/baselines/reference/asyncImportedPromise_es6.symbols
+++ b/tests/baselines/reference/asyncImportedPromise_es6.symbols
@@ -2,7 +2,7 @@
 export class Task<T> extends Promise<T> { }
 >Task : Symbol(Task, Decl(task.ts, 0, 0))
 >T : Symbol(T, Decl(task.ts, 0, 18))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(task.ts, 0, 18))
 
 === tests/cases/conformance/async/es6/test.ts ===
diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols b/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols
index 86f14f2da74..6965ef361d2 100644
--- a/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols
+++ b/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols
@@ -5,7 +5,7 @@ namespace X {
     export class MyPromise<T> extends Promise<T> {
 >MyPromise : Symbol(MyPromise, Decl(asyncQualifiedReturnType_es6.ts, 0, 13))
 >T : Symbol(T, Decl(asyncQualifiedReturnType_es6.ts, 1, 27))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(asyncQualifiedReturnType_es6.ts, 1, 27))
     }
 }
diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols
index afc6968eedb..dd896b88138 100644
--- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols
+++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols
@@ -2,7 +2,7 @@
 declare function someOtherFunction(i: any): Promise<void>;
 >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0))
 >i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 35))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const x = async i => await someOtherFunction(i)
 >x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 5))
diff --git a/tests/baselines/reference/asyncUseStrict_es6.symbols b/tests/baselines/reference/asyncUseStrict_es6.symbols
index deecf6b81fe..79a93033aef 100644
--- a/tests/baselines/reference/asyncUseStrict_es6.symbols
+++ b/tests/baselines/reference/asyncUseStrict_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(asyncUseStrict_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(asyncUseStrict_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     "use strict";
     var b = await p || a;
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
index f65763b36a3..68052539ce2 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
index 52fa3178d8a..4b4c5d9f8d1 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
index db67f41e3a4..5d2f580413c 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
@@ -4,7 +4,7 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
index 3f16bd0ca6f..f1712ff9acb 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
index 2182062def1..2528c33b466 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols
index 8f08901eee7..a4e9ed32efb 100644
--- a/tests/baselines/reference/awaitCallExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression1_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols
index 335af879cd2..dd0b5f0cacc 100644
--- a/tests/baselines/reference/awaitCallExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression2_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols
index 7e28ec765ba..08ed94d6331 100644
--- a/tests/baselines/reference/awaitCallExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression3_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols
index efc2c9275b6..92dbd857d0a 100644
--- a/tests/baselines/reference/awaitCallExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression4_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols
index 2861eeb1333..54dd4341869 100644
--- a/tests/baselines/reference/awaitCallExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression5_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols
index dc7c711e900..00d9b4f4be2 100644
--- a/tests/baselines/reference/awaitCallExpression6_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression6_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols
index 17d143e5312..24be2b5c844 100644
--- a/tests/baselines/reference/awaitCallExpression7_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression7_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols
index 1b98fc1f4de..6a8d45250b9 100644
--- a/tests/baselines/reference/awaitCallExpression8_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression8_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitClassExpression_es6.symbols b/tests/baselines/reference/awaitClassExpression_es6.symbols
index 6162e121c81..712bd8f51a4 100644
--- a/tests/baselines/reference/awaitClassExpression_es6.symbols
+++ b/tests/baselines/reference/awaitClassExpression_es6.symbols
@@ -4,12 +4,12 @@ declare class C { }
 
 declare var p: Promise<typeof C>;
 >p : Symbol(p, Decl(awaitClassExpression_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >C : Symbol(C, Decl(awaitClassExpression_es6.ts, 0, 0))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitClassExpression_es6.ts, 1, 33))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     class D extends (await p) {
 >D : Symbol(D, Decl(awaitClassExpression_es6.ts, 3, 38))
diff --git a/tests/baselines/reference/awaitUnion_es6.symbols b/tests/baselines/reference/awaitUnion_es6.symbols
index c301f3c5b8d..114ef267287 100644
--- a/tests/baselines/reference/awaitUnion_es6.symbols
+++ b/tests/baselines/reference/awaitUnion_es6.symbols
@@ -4,20 +4,20 @@ declare let a: number | string;
 
 declare let b: PromiseLike<number> | PromiseLike<string>;
 >b : Symbol(b, Decl(awaitUnion_es6.ts, 1, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es6.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es6.d.ts, --, --))
 
 declare let c: PromiseLike<number | string>;
 >c : Symbol(c, Decl(awaitUnion_es6.ts, 2, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es6.d.ts, --, --))
 
 declare let d: number | PromiseLike<string>;
 >d : Symbol(d, Decl(awaitUnion_es6.ts, 3, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es6.d.ts, --, --))
 
 declare let e: number | PromiseLike<number | string>;
 >e : Symbol(e, Decl(awaitUnion_es6.ts, 4, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es6.d.ts, --, --))
 
 async function f() {
 >f : Symbol(f, Decl(awaitUnion_es6.ts, 4, 53))
diff --git a/tests/baselines/reference/bindingPatternInParameter01.errors.txt b/tests/baselines/reference/bindingPatternInParameter01.errors.txt
deleted file mode 100644
index bee1f47141e..00000000000
--- a/tests/baselines/reference/bindingPatternInParameter01.errors.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-tests/cases/compiler/bindingPatternInParameter01.ts(4,3): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/bindingPatternInParameter01.ts (1 errors) ====
-    const nestedArray = [[[1, 2]], [[3, 4]]];
-    
-    nestedArray.forEach(([[a, b]]) => {
-      console.log(a, b);
-      ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    });
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/bindingPatternInParameter01.symbols b/tests/baselines/reference/bindingPatternInParameter01.symbols
index 466c7a0bc70..01bb9b3eb25 100644
--- a/tests/baselines/reference/bindingPatternInParameter01.symbols
+++ b/tests/baselines/reference/bindingPatternInParameter01.symbols
@@ -10,6 +10,9 @@ nestedArray.forEach(([[a, b]]) => {
 >b : Symbol(b, Decl(bindingPatternInParameter01.ts, 2, 25))
 
   console.log(a, b);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(bindingPatternInParameter01.ts, 2, 23))
 >b : Symbol(b, Decl(bindingPatternInParameter01.ts, 2, 25))
 
diff --git a/tests/baselines/reference/bindingPatternInParameter01.types b/tests/baselines/reference/bindingPatternInParameter01.types
index 927deae8c07..4fac8c8fd7d 100644
--- a/tests/baselines/reference/bindingPatternInParameter01.types
+++ b/tests/baselines/reference/bindingPatternInParameter01.types
@@ -21,10 +21,10 @@ nestedArray.forEach(([[a, b]]) => {
 >b : number
 
   console.log(a, b);
->console.log(a, b) : any
->console.log : any
->console : any
->log : any
+>console.log(a, b) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >a : number
 >b : number
 
diff --git a/tests/baselines/reference/binopAssignmentShouldHaveType.symbols b/tests/baselines/reference/binopAssignmentShouldHaveType.symbols
index ae7a3c521af..70c594628bf 100644
--- a/tests/baselines/reference/binopAssignmentShouldHaveType.symbols
+++ b/tests/baselines/reference/binopAssignmentShouldHaveType.symbols
@@ -21,12 +21,12 @@ module Test {
 >name : Symbol(name, Decl(binopAssignmentShouldHaveType.ts, 8, 6))
 
    if ((name= this.getName()).length > 0) {
->(name= this.getName()).length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>(name= this.getName()).length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >name : Symbol(name, Decl(binopAssignmentShouldHaveType.ts, 8, 6))
 >this.getName : Symbol(Bug.getName, Decl(binopAssignmentShouldHaveType.ts, 3, 19))
 >this : Symbol(Bug, Decl(binopAssignmentShouldHaveType.ts, 2, 13))
 >getName : Symbol(Bug.getName, Decl(binopAssignmentShouldHaveType.ts, 3, 19))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 
     console.log(name);
 >console : Symbol(console, Decl(binopAssignmentShouldHaveType.ts, 0, 11))
diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols
index f1fa53d7b6c..a281c738027 100644
--- a/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols
+++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols
@@ -195,8 +195,8 @@ interface A { // T
 
             (a: Date): Date;
 >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance2.ts, 42, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         }): any[];
     };
diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols
index dd12cd81806..872ce131917 100644
--- a/tests/baselines/reference/callWithSpreadES6.symbols
+++ b/tests/baselines/reference/callWithSpreadES6.symbols
@@ -93,7 +93,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpreadES6.ts, 7, 3))
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
 >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 10, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 0, 13))
diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols
index ff1054c2b21..525bc529e16 100644
--- a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols
+++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols
@@ -9,9 +9,9 @@ function foo0(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 3, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 12))
@@ -32,9 +32,9 @@ function foo0_1(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 11, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 12))
@@ -57,9 +57,9 @@ function foo1(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 19, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 12))
@@ -78,9 +78,9 @@ function foo2(x) {
     while (1 === 1) {
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 27, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 25, 14))
@@ -102,9 +102,9 @@ function foo3(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 35, 11))
@@ -128,9 +128,9 @@ function foo4(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 44, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         let x = 1;
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11))
@@ -157,9 +157,9 @@ function foo5(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 53, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 12))
@@ -185,9 +185,9 @@ function foo6(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 62, 11))
@@ -212,9 +212,9 @@ function foo7(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 71, 11))
@@ -244,9 +244,9 @@ function foo8(x) {
 
         let a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 81, 11))
@@ -269,9 +269,9 @@ function foo0_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 90, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 14))
@@ -292,9 +292,9 @@ function foo0_1_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 98, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 14))
@@ -316,9 +316,9 @@ function foo1_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 106, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 14))
@@ -337,9 +337,9 @@ function foo2_c(x) {
     while (1 === 1) {
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 114, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 112, 16))
@@ -361,9 +361,9 @@ function foo3_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 122, 13))
@@ -386,9 +386,9 @@ function foo4_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 131, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         const x = 1;
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13))
@@ -414,9 +414,9 @@ function foo5_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 140, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 14))
@@ -442,9 +442,9 @@ function foo6_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 149, 13))
@@ -469,9 +469,9 @@ function foo7_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 158, 13))
@@ -500,9 +500,9 @@ function foo8_c(x) {
 
         const a = arguments.length;
 >a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return x + y + a });
 >x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 168, 13))
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
index 4d4013096fc..f20c6596431 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
@@ -126,9 +126,9 @@ function foo() {
 >z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 21))
 >x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 67, 33))
 >y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 67, 38))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
             if (b === 1) {
 >b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 66, 16))
@@ -246,24 +246,24 @@ function foo3 () {
 
     let x = arguments.length;
 >x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 131, 7))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
     for (let y of []) {
 >y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 132, 12))
 
         let z = arguments.length;
 >z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 133, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 
         (function() { return y + z + arguments.length; });
 >y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 132, 12))
 >z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 133, 11))
->arguments.length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>arguments.length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(IArguments.length, Decl(lib.es6.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/chainedAssignment2.symbols b/tests/baselines/reference/chainedAssignment2.symbols
index 0f37d41c3be..fe3b67e47cb 100644
--- a/tests/baselines/reference/chainedAssignment2.symbols
+++ b/tests/baselines/reference/chainedAssignment2.symbols
@@ -10,7 +10,7 @@ var c: boolean;
 
 var d: Date;
 >d : Symbol(d, Decl(chainedAssignment2.ts, 3, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var e: RegExp;
 >e : Symbol(e, Decl(chainedAssignment2.ts, 4, 3))
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
index 2cf04ac05d3..1ce28c7aab8 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
@@ -12,9 +12,9 @@ for (let i = 0; i < 3; i++) {
 >i : Symbol(i, Decl(classExpressionWithStaticProperties3.ts, 2, 8))
 
     arr.push(class C {
->arr.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 3, 13))
 
         static x = i;
@@ -30,9 +30,9 @@ for (let i = 0; i < 3; i++) {
     });
 }
 arr.forEach(C => console.log(C.y()));
->arr.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 8, 12))
 >console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 0, 11))
 >C.y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12))
diff --git a/tests/baselines/reference/classExtendingBuiltinType.symbols b/tests/baselines/reference/classExtendingBuiltinType.symbols
index fb0814cc0f2..d7ef51fe510 100644
--- a/tests/baselines/reference/classExtendingBuiltinType.symbols
+++ b/tests/baselines/reference/classExtendingBuiltinType.symbols
@@ -21,7 +21,7 @@ class C5 extends Number { }
 
 class C6 extends Date { }
 >C6 : Symbol(C6, Decl(classExtendingBuiltinType.ts, 4, 27))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C7 extends RegExp { }
 >C7 : Symbol(C7, Decl(classExtendingBuiltinType.ts, 5, 25))
diff --git a/tests/baselines/reference/classWithoutExplicitConstructor.symbols b/tests/baselines/reference/classWithoutExplicitConstructor.symbols
index 103fcd30bef..e75ef83d8af 100644
--- a/tests/baselines/reference/classWithoutExplicitConstructor.symbols
+++ b/tests/baselines/reference/classWithoutExplicitConstructor.symbols
@@ -20,7 +20,7 @@ var c2 = new C(null); // error
 class D<T extends Date> {
 >D : Symbol(D, Decl(classWithoutExplicitConstructor.ts, 6, 21))
 >T : Symbol(T, Decl(classWithoutExplicitConstructor.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     x = 2
 >x : Symbol(D.x, Decl(classWithoutExplicitConstructor.ts, 8, 25))
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
index 6df26708078..f3189aad873 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
@@ -82,7 +82,7 @@ true, {}
 >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3))
 
 "string", new Date()
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 STRING.toLowerCase(), new CLASS()
 >STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
@@ -110,7 +110,7 @@ var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" });
 
 var resultIsObject10 = ("string", new Date());
 >resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var resultIsObject11 = (STRING.toLowerCase(), new CLASS());
 >resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3))
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols
index 2d9fc665a81..02a375ea93e 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols
@@ -71,7 +71,7 @@ null, STRING;
 
 ANY = new Date(), STRING;
 >ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3))
 
 true, "";
@@ -96,7 +96,7 @@ var resultIsString6 = (null, STRING);
 var resultIsString7 = (ANY = new Date(), STRING);
 >resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3))
 >ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3))
 
 var resultIsString8 = (true, "");
diff --git a/tests/baselines/reference/computedPropertyNames3_ES6.symbols b/tests/baselines/reference/computedPropertyNames3_ES6.symbols
index 7e51c7a2298..049da49e5a5 100644
--- a/tests/baselines/reference/computedPropertyNames3_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames3_ES6.symbols
@@ -14,7 +14,7 @@ class C {
 >v : Symbol(v, Decl(computedPropertyNames3_ES6.ts, 5, 17))
 
     static get [<String>""]() { }
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
     static set [id.toString()](v) { }
 >id : Symbol(id, Decl(computedPropertyNames3_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
index ef5d519c3a0..5519781b79a 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
@@ -17,13 +17,13 @@ var o: I = {
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>y.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
     ["" + 1]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
->y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>y.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
index d8cab4c4a52..c1507c501ef 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
@@ -17,13 +17,13 @@ var o: I = {
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>y.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
     [+"bar"]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
->y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>y.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
index deea9bff3df..2d3d48fe304 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
@@ -13,13 +13,13 @@ var o: I = {
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13))
->y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>y.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
     [+"bar"]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>y.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
index 2c000f17bf6..4473580e464 100644
--- a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
@@ -120,7 +120,7 @@ foo() ? exprAny1 : exprAny2;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
 
 new Date() ? exprBoolean1 : exprBoolean2;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
@@ -144,7 +144,7 @@ condObject.valueOf() ? exprIsObject1 : exprIsObject2;
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3))
 
 new Date() ? exprString1 : exprBoolean1; // union
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 
@@ -237,7 +237,7 @@ var resultIsAny3 = foo() ? exprAny1 : exprAny2;
 
 var resultIsBoolean3 = new Date() ? exprBoolean1 : exprBoolean2;
 >resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(conditionalOperatorConditionIsObjectType.ts, 58, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
diff --git a/tests/baselines/reference/constDeclarations-access2.symbols b/tests/baselines/reference/constDeclarations-access2.symbols
index 0f67618b1ad..5fdea9bf1b8 100644
--- a/tests/baselines/reference/constDeclarations-access2.symbols
+++ b/tests/baselines/reference/constDeclarations-access2.symbols
@@ -83,7 +83,7 @@ x;
 >x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
 
 x.toString();
->x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>x.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(constDeclarations-access2.ts, 0, 5))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/constDeclarations-access3.symbols b/tests/baselines/reference/constDeclarations-access3.symbols
index 43049ff355a..ef064d931ef 100644
--- a/tests/baselines/reference/constDeclarations-access3.symbols
+++ b/tests/baselines/reference/constDeclarations-access3.symbols
@@ -139,9 +139,9 @@ M.x;
 >x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 
 M.x.toString();
->M.x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>M.x.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 >M.x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
 >M : Symbol(M, Decl(constDeclarations-access3.ts, 0, 0))
 >x : Symbol(M.x, Decl(constDeclarations-access3.ts, 1, 16))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/constDeclarations-access4.symbols b/tests/baselines/reference/constDeclarations-access4.symbols
index 4e5179f1e81..e276d4ba5db 100644
--- a/tests/baselines/reference/constDeclarations-access4.symbols
+++ b/tests/baselines/reference/constDeclarations-access4.symbols
@@ -139,9 +139,9 @@ M.x;
 >x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 
 M.x.toString();
->M.x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>M.x.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 >M.x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
 >M : Symbol(M, Decl(constDeclarations-access4.ts, 0, 0))
 >x : Symbol(M.x, Decl(constDeclarations-access4.ts, 1, 9))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/constDeclarations-access5.symbols b/tests/baselines/reference/constDeclarations-access5.symbols
index 776f78b8015..fe20fc4da2a 100644
--- a/tests/baselines/reference/constDeclarations-access5.symbols
+++ b/tests/baselines/reference/constDeclarations-access5.symbols
@@ -139,11 +139,11 @@ m.x;
 >x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 
 m.x.toString();
->m.x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>m.x.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 >m.x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
 >m : Symbol(m, Decl(constDeclarations_access_2.ts, 0, 0))
 >x : Symbol(m.x, Decl(constDeclarations_access_1.ts, 0, 12))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
 === tests/cases/compiler/constDeclarations_access_1.ts ===
 export const x = 0;
diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols b/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols
index 4d63a7f2db4..e56a1f77211 100644
--- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols
+++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols
@@ -195,8 +195,8 @@ interface A { // T
 
             new (a: Date): Date;
 >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance2.ts, 42, 17))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         }): any[];
     };
diff --git a/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols b/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols
index 7403c126f45..4693d6d3b01 100644
--- a/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols
+++ b/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols
@@ -34,7 +34,7 @@ class D<T> {
 class E<T extends Date> {
 >E : Symbol(E, Decl(constructorImplementationWithDefaultValues.ts, 12, 1))
 >T : Symbol(T, Decl(constructorImplementationWithDefaultValues.ts, 14, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x);
 >x : Symbol(x, Decl(constructorImplementationWithDefaultValues.ts, 15, 16))
diff --git a/tests/baselines/reference/constructorImplementationWithDefaultValues2.symbols b/tests/baselines/reference/constructorImplementationWithDefaultValues2.symbols
index 69c26e440c8..fa7434ae5b2 100644
--- a/tests/baselines/reference/constructorImplementationWithDefaultValues2.symbols
+++ b/tests/baselines/reference/constructorImplementationWithDefaultValues2.symbols
@@ -41,7 +41,7 @@ class D<T, U> {
 class E<T extends Date> {
 >E : Symbol(E, Decl(constructorImplementationWithDefaultValues2.ts, 12, 1))
 >T : Symbol(T, Decl(constructorImplementationWithDefaultValues2.ts, 14, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x);
 >x : Symbol(x, Decl(constructorImplementationWithDefaultValues2.ts, 15, 16))
@@ -49,7 +49,7 @@ class E<T extends Date> {
     constructor(x: T = new Date()) { // error
 >x : Symbol(x, Decl(constructorImplementationWithDefaultValues2.ts, 16, 16))
 >T : Symbol(T, Decl(constructorImplementationWithDefaultValues2.ts, 14, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var y = x;
 >y : Symbol(y, Decl(constructorImplementationWithDefaultValues2.ts, 17, 11))
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
index 708f175c002..7ef600f2766 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
@@ -18,9 +18,7 @@ tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,28): error TS
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,41): error TS1005: ';' expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,45): error TS1002: Unterminated string literal.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and '0'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(47,17): error TS2304: Cannot find name 'console'.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(49,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(53,13): error TS2304: Cannot find name 'console'.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(58,5): error TS1128: Declaration or statement expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(69,13): error TS1109: Expression expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(72,37): error TS1127: Invalid character.
@@ -87,7 +85,7 @@ tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,55): error T
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (87 errors) ====
+==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (85 errors) ====
     declare module "fs" {
         export class File {
             constructor(filename: string);
@@ -178,8 +176,6 @@ tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS
                 }
                 catch (e) {
                     console.log(e);
-                    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
                 }
                 finally {
                 ~~~~~~~
@@ -188,8 +184,6 @@ tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS
                 }
     
                 console.log('Done');
-                ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
     
                 return 0;
     
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.symbols b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.symbols
index 7374c67325d..65b763379ea 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.symbols
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.symbols
@@ -86,6 +86,9 @@ module TypeScriptAllInOne {
 >e : Symbol(e, Decl(constructorWithIncompleteTypeAnnotation.ts, 45, 19))
 
                 console.log(e);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(constructorWithIncompleteTypeAnnotation.ts, 45, 19))
             }
             finally {
@@ -93,6 +96,9 @@ module TypeScriptAllInOne {
             }
 
             console.log('Done');
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 
             return 0;
 
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types
index a0c5f95cbbd..e6257349584 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types
@@ -128,10 +128,10 @@ module TypeScriptAllInOne {
 >e : any
 
                 console.log(e);
->console.log(e) : any
->console.log : any
->console : any
->log : any
+>console.log(e) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >e : any
             }
             finally {
@@ -139,10 +139,10 @@ module TypeScriptAllInOne {
             }
 
             console.log('Done');
->console.log('Done') : any
->console.log : any
->console : any
->log : any
+>console.log('Done') : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >'Done' : "Done"
 
             return 0;
diff --git a/tests/baselines/reference/contextualTypingOfArrayLiterals1.symbols b/tests/baselines/reference/contextualTypingOfArrayLiterals1.symbols
index 5e4c341736b..49467dee86f 100644
--- a/tests/baselines/reference/contextualTypingOfArrayLiterals1.symbols
+++ b/tests/baselines/reference/contextualTypingOfArrayLiterals1.symbols
@@ -4,13 +4,13 @@ interface I {
 
    [x: number]: Date;
 >x : Symbol(x, Decl(contextualTypingOfArrayLiterals1.ts, 1, 4))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var x3: I = [new Date(), 1]; 
 >x3 : Symbol(x3, Decl(contextualTypingOfArrayLiterals1.ts, 4, 3))
 >I : Symbol(I, Decl(contextualTypingOfArrayLiterals1.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r2 = x3[1]; 
 >r2 : Symbol(r2, Decl(contextualTypingOfArrayLiterals1.ts, 5, 3))
diff --git a/tests/baselines/reference/contextualTypingOfGenericFunctionTypedArguments1.symbols b/tests/baselines/reference/contextualTypingOfGenericFunctionTypedArguments1.symbols
index 203d85b181d..9b7ad31d01c 100644
--- a/tests/baselines/reference/contextualTypingOfGenericFunctionTypedArguments1.symbols
+++ b/tests/baselines/reference/contextualTypingOfGenericFunctionTypedArguments1.symbols
@@ -29,7 +29,7 @@ interface Combinators {
 >f : Symbol(f, Decl(contextualTypingOfGenericFunctionTypedArguments1.ts, 7, 32))
 >x : Symbol(x, Decl(contextualTypingOfGenericFunctionTypedArguments1.ts, 7, 37))
 >T : Symbol(T, Decl(contextualTypingOfGenericFunctionTypedArguments1.ts, 7, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var c2: Collection<number>;
diff --git a/tests/baselines/reference/contextualTypingOfTooShortOverloads.symbols b/tests/baselines/reference/contextualTypingOfTooShortOverloads.symbols
index 8f196cf4825..dedfd7b6fa5 100644
--- a/tests/baselines/reference/contextualTypingOfTooShortOverloads.symbols
+++ b/tests/baselines/reference/contextualTypingOfTooShortOverloads.symbols
@@ -81,8 +81,8 @@ interface IRouterMatcher<T> {
 
 type PathParams = string | RegExp | (string | RegExp)[];
 >PathParams : Symbol(PathParams, Decl(contextualTypingOfTooShortOverloads.ts, 25, 1))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 type RequestHandlerParams = RequestHandler | ErrorRequestHandler | (RequestHandler | ErrorRequestHandler)[];
 >RequestHandlerParams : Symbol(RequestHandlerParams, Decl(contextualTypingOfTooShortOverloads.ts, 27, 56))
diff --git a/tests/baselines/reference/controlFlowInstanceof.symbols b/tests/baselines/reference/controlFlowInstanceof.symbols
index f61f6b58616..8ca252c2bef 100644
--- a/tests/baselines/reference/controlFlowInstanceof.symbols
+++ b/tests/baselines/reference/controlFlowInstanceof.symbols
@@ -4,19 +4,19 @@
 function f1(s: Set<string> | Set<number>) {
 >f1 : Symbol(f1, Decl(controlFlowInstanceof.ts, 0, 0))
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s = new Set<number>();
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s;  // Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
 
     if (s instanceof Set) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         s;  // Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
@@ -25,27 +25,27 @@ function f1(s: Set<string> | Set<number>) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
 
     s.add(42);
->s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+>s.add : Symbol(Set.add, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 2, 12))
->add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+>add : Symbol(Set.add, Decl(lib.es6.d.ts, --, --))
 }
 
 function f2(s: Set<string> | Set<number>) {
 >f2 : Symbol(f2, Decl(controlFlowInstanceof.ts, 10, 1))
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s = new Set<number>();
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s;  // Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
 
     if (s instanceof Promise) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         s;  // Set<number> & Promise<any>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
@@ -54,23 +54,23 @@ function f2(s: Set<string> | Set<number>) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
 
     s.add(42);
->s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+>s.add : Symbol(Set.add, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 12, 12))
->add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+>add : Symbol(Set.add, Decl(lib.es6.d.ts, --, --))
 }
 
 function f3(s: Set<string> | Set<number>) {
 >f3 : Symbol(f3, Decl(controlFlowInstanceof.ts, 20, 1))
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s;  // Set<string> | Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12))
 
     if (s instanceof Set) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         s;  // Set<string> | Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 22, 12))
@@ -84,19 +84,19 @@ function f3(s: Set<string> | Set<number>) {
 function f4(s: Set<string> | Set<number>) {
 >f4 : Symbol(f4, Decl(controlFlowInstanceof.ts, 30, 1))
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s = new Set<number>();
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     s;  // Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12))
 
     if (s instanceof Set) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         s;  // Set<number>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 32, 12))
diff --git a/tests/baselines/reference/controlFlowLoopAnalysis.js b/tests/baselines/reference/controlFlowLoopAnalysis.js
index fa8dc29e92a..de2f457959c 100644
--- a/tests/baselines/reference/controlFlowLoopAnalysis.js
+++ b/tests/baselines/reference/controlFlowLoopAnalysis.js
@@ -77,7 +77,7 @@ function test2() {
 // Repro from #8511
 function mapUntilCant(values, canTake, mapping) {
     var result = [];
-    for (var index = 0, length = values.length; index < length; index++) {
+    for (var index = 0, length_1 = values.length; index < length_1; index++) {
         var value = values[index];
         if (canTake(value, index)) {
             result.push(mapping(value, index));
diff --git a/tests/baselines/reference/copyrightWithNewLine1.errors.txt b/tests/baselines/reference/copyrightWithNewLine1.errors.txt
index 11c34ed86a7..9f5932a2b2e 100644
--- a/tests/baselines/reference/copyrightWithNewLine1.errors.txt
+++ b/tests/baselines/reference/copyrightWithNewLine1.errors.txt
@@ -1,8 +1,7 @@
 tests/cases/compiler/copyrightWithNewLine1.ts(5,24): error TS2307: Cannot find module './greeter'.
-tests/cases/compiler/copyrightWithNewLine1.ts(6,10): error TS2304: Cannot find name 'document'.
 
 
-==== tests/cases/compiler/copyrightWithNewLine1.ts (2 errors) ====
+==== tests/cases/compiler/copyrightWithNewLine1.ts (1 errors) ====
     /*****************************
     * (c) Copyright - Important
     ****************************/
@@ -11,8 +10,6 @@ tests/cases/compiler/copyrightWithNewLine1.ts(6,10): error TS2304: Cannot find n
                            ~~~~~~~~~~~
 !!! error TS2307: Cannot find module './greeter'.
     var el = document.getElementById('content');
-             ~~~~~~~~
-!!! error TS2304: Cannot find name 'document'.
     var greeter = new model.Greeter(el);
     /** things */
     greeter.start();
\ No newline at end of file
diff --git a/tests/baselines/reference/copyrightWithNewLine1.symbols b/tests/baselines/reference/copyrightWithNewLine1.symbols
index 85b32678786..7d471ba6480 100644
--- a/tests/baselines/reference/copyrightWithNewLine1.symbols
+++ b/tests/baselines/reference/copyrightWithNewLine1.symbols
@@ -8,6 +8,9 @@ import model = require("./greeter")
 
 var el = document.getElementById('content');
 >el : Symbol(el, Decl(copyrightWithNewLine1.ts, 5, 3))
+>document.getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --))
+>document : Symbol(document, Decl(lib.d.ts, --, --))
+>getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --))
 
 var greeter = new model.Greeter(el);
 >greeter : Symbol(greeter, Decl(copyrightWithNewLine1.ts, 6, 3))
diff --git a/tests/baselines/reference/copyrightWithNewLine1.types b/tests/baselines/reference/copyrightWithNewLine1.types
index 7130bda51ac..b51de4f434e 100644
--- a/tests/baselines/reference/copyrightWithNewLine1.types
+++ b/tests/baselines/reference/copyrightWithNewLine1.types
@@ -7,11 +7,11 @@ import model = require("./greeter")
 >model : any
 
 var el = document.getElementById('content');
->el : any
->document.getElementById('content') : any
->document.getElementById : any
->document : any
->getElementById : any
+>el : HTMLElement
+>document.getElementById('content') : HTMLElement
+>document.getElementById : (elementId: string) => HTMLElement
+>document : Document
+>getElementById : (elementId: string) => HTMLElement
 >'content' : "content"
 
 var greeter = new model.Greeter(el);
@@ -20,7 +20,7 @@ var greeter = new model.Greeter(el);
 >model.Greeter : any
 >model : any
 >Greeter : any
->el : any
+>el : HTMLElement
 
 /** things */
 greeter.start();
diff --git a/tests/baselines/reference/copyrightWithoutNewLine1.errors.txt b/tests/baselines/reference/copyrightWithoutNewLine1.errors.txt
index d7f5f3129c7..71194988ca2 100644
--- a/tests/baselines/reference/copyrightWithoutNewLine1.errors.txt
+++ b/tests/baselines/reference/copyrightWithoutNewLine1.errors.txt
@@ -1,8 +1,7 @@
 tests/cases/compiler/copyrightWithoutNewLine1.ts(4,24): error TS2307: Cannot find module './greeter'.
-tests/cases/compiler/copyrightWithoutNewLine1.ts(5,10): error TS2304: Cannot find name 'document'.
 
 
-==== tests/cases/compiler/copyrightWithoutNewLine1.ts (2 errors) ====
+==== tests/cases/compiler/copyrightWithoutNewLine1.ts (1 errors) ====
     /*****************************
     * (c) Copyright - Important
     ****************************/
@@ -10,8 +9,6 @@ tests/cases/compiler/copyrightWithoutNewLine1.ts(5,10): error TS2304: Cannot fin
                            ~~~~~~~~~~~
 !!! error TS2307: Cannot find module './greeter'.
     var el = document.getElementById('content');
-             ~~~~~~~~
-!!! error TS2304: Cannot find name 'document'.
     var greeter = new model.Greeter(el);
     /** things */
     greeter.start();
\ No newline at end of file
diff --git a/tests/baselines/reference/copyrightWithoutNewLine1.symbols b/tests/baselines/reference/copyrightWithoutNewLine1.symbols
index 50ee2f932da..cfed1133753 100644
--- a/tests/baselines/reference/copyrightWithoutNewLine1.symbols
+++ b/tests/baselines/reference/copyrightWithoutNewLine1.symbols
@@ -7,6 +7,9 @@ import model = require("./greeter")
 
 var el = document.getElementById('content');
 >el : Symbol(el, Decl(copyrightWithoutNewLine1.ts, 4, 3))
+>document.getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --))
+>document : Symbol(document, Decl(lib.d.ts, --, --))
+>getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --))
 
 var greeter = new model.Greeter(el);
 >greeter : Symbol(greeter, Decl(copyrightWithoutNewLine1.ts, 5, 3))
diff --git a/tests/baselines/reference/copyrightWithoutNewLine1.types b/tests/baselines/reference/copyrightWithoutNewLine1.types
index d54f9fae4d9..bdb9bd0e44d 100644
--- a/tests/baselines/reference/copyrightWithoutNewLine1.types
+++ b/tests/baselines/reference/copyrightWithoutNewLine1.types
@@ -6,11 +6,11 @@ import model = require("./greeter")
 >model : any
 
 var el = document.getElementById('content');
->el : any
->document.getElementById('content') : any
->document.getElementById : any
->document : any
->getElementById : any
+>el : HTMLElement
+>document.getElementById('content') : HTMLElement
+>document.getElementById : (elementId: string) => HTMLElement
+>document : Document
+>getElementById : (elementId: string) => HTMLElement
 >'content' : "content"
 
 var greeter = new model.Greeter(el);
@@ -19,7 +19,7 @@ var greeter = new model.Greeter(el);
 >model.Greeter : any
 >model : any
 >Greeter : any
->el : any
+>el : HTMLElement
 
 /** things */
 greeter.start();
diff --git a/tests/baselines/reference/covariantCallbacks.symbols b/tests/baselines/reference/covariantCallbacks.symbols
index 5e1325de3ec..d29948e1719 100644
--- a/tests/baselines/reference/covariantCallbacks.symbols
+++ b/tests/baselines/reference/covariantCallbacks.symbols
@@ -43,10 +43,10 @@ function f1(a: P<A>, b: P<B>) {
 function f2(a: Promise<A>, b: Promise<B>) {
 >f2 : Symbol(f2, Decl(covariantCallbacks.ts, 12, 1))
 >a : Symbol(a, Decl(covariantCallbacks.ts, 14, 12))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >A : Symbol(A, Decl(covariantCallbacks.ts, 4, 2))
 >b : Symbol(b, Decl(covariantCallbacks.ts, 14, 26))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >B : Symbol(B, Decl(covariantCallbacks.ts, 6, 25))
 
     a = b;
diff --git a/tests/baselines/reference/customEventDetail.errors.txt b/tests/baselines/reference/customEventDetail.errors.txt
deleted file mode 100644
index f243dc64c34..00000000000
--- a/tests/baselines/reference/customEventDetail.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/customEventDetail.ts(1,8): error TS2304: Cannot find name 'CustomEvent'.
-
-
-==== tests/cases/compiler/customEventDetail.ts (1 errors) ====
-    var x: CustomEvent;
-           ~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'CustomEvent'.
-    
-    // valid since detail is any
-    x.initCustomEvent('hello', true, true, { id: 12, name: 'hello' });
-    var y = x.detail.name;
\ No newline at end of file
diff --git a/tests/baselines/reference/customEventDetail.symbols b/tests/baselines/reference/customEventDetail.symbols
index 7bdce2e92f0..4c543d6eb0e 100644
--- a/tests/baselines/reference/customEventDetail.symbols
+++ b/tests/baselines/reference/customEventDetail.symbols
@@ -1,14 +1,19 @@
 === tests/cases/compiler/customEventDetail.ts ===
 var x: CustomEvent;
 >x : Symbol(x, Decl(customEventDetail.ts, 0, 3))
+>CustomEvent : Symbol(CustomEvent, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // valid since detail is any
 x.initCustomEvent('hello', true, true, { id: 12, name: 'hello' });
+>x.initCustomEvent : Symbol(CustomEvent.initCustomEvent, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(customEventDetail.ts, 0, 3))
+>initCustomEvent : Symbol(CustomEvent.initCustomEvent, Decl(lib.d.ts, --, --))
 >id : Symbol(id, Decl(customEventDetail.ts, 3, 40))
 >name : Symbol(name, Decl(customEventDetail.ts, 3, 48))
 
 var y = x.detail.name;
 >y : Symbol(y, Decl(customEventDetail.ts, 4, 3))
+>x.detail : Symbol(CustomEvent.detail, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(customEventDetail.ts, 0, 3))
+>detail : Symbol(CustomEvent.detail, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/customEventDetail.types b/tests/baselines/reference/customEventDetail.types
index 2a32ae0e13b..c7e1ffd2128 100644
--- a/tests/baselines/reference/customEventDetail.types
+++ b/tests/baselines/reference/customEventDetail.types
@@ -1,14 +1,14 @@
 === tests/cases/compiler/customEventDetail.ts ===
 var x: CustomEvent;
->x : any
->CustomEvent : No type information available!
+>x : CustomEvent
+>CustomEvent : CustomEvent
 
 // valid since detail is any
 x.initCustomEvent('hello', true, true, { id: 12, name: 'hello' });
->x.initCustomEvent('hello', true, true, { id: 12, name: 'hello' }) : any
->x.initCustomEvent : any
->x : any
->initCustomEvent : any
+>x.initCustomEvent('hello', true, true, { id: 12, name: 'hello' }) : void
+>x.initCustomEvent : (typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: any) => void
+>x : CustomEvent
+>initCustomEvent : (typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: any) => void
 >'hello' : "hello"
 >true : true
 >true : true
@@ -22,7 +22,7 @@ var y = x.detail.name;
 >y : any
 >x.detail.name : any
 >x.detail : any
->x : any
+>x : CustomEvent
 >detail : any
 >name : any
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols
index 168971f364f..1dc33ab3325 100644
--- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.symbols
@@ -36,7 +36,7 @@ module M {
 }
 
 interface Window {
->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1))
 
     someMethod();
 >someMethod : Symbol(Window.someMethod, Decl(declFileTypeAnnotationTypeAlias.ts, 19, 18))
@@ -47,7 +47,7 @@ module M {
 
     export type W = Window | string;
 >W : Symbol(W, Decl(declFileTypeAnnotationTypeAlias.ts, 23, 10))
->Window : Symbol(Window, Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(declFileTypeAnnotationTypeAlias.ts, 17, 1))
 
     export module N {
 >N : Symbol(N, Decl(declFileTypeAnnotationTypeAlias.ts, 24, 36))
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols
index 69a55a72c0e..75c71d0e7c3 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols
@@ -1,6 +1,6 @@
 === tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts ===
 interface Window {
->Window : Symbol(Window, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 0))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 0))
 
     someMethod();
 >someMethod : Symbol(Window.someMethod, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 18))
@@ -11,7 +11,7 @@ module M {
 
     type W = Window | string;
 >W : Symbol(W, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 4, 10))
->Window : Symbol(Window, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 0))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 0))
 
     export module N {
 >N : Symbol(N, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 5, 29))
@@ -30,7 +30,7 @@ module M1 {
 
     export type W = Window | string;
 >W : Symbol(W, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 12, 11))
->Window : Symbol(Window, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 0))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 0, 0))
 
     export module N {
 >N : Symbol(N, Decl(declFileTypeAnnotationVisibilityErrorTypeAlias.ts, 13, 36))
diff --git a/tests/baselines/reference/declarationEmitPromise.symbols b/tests/baselines/reference/declarationEmitPromise.symbols
index 2e9185d2e39..71a31bea469 100644
--- a/tests/baselines/reference/declarationEmitPromise.symbols
+++ b/tests/baselines/reference/declarationEmitPromise.symbols
@@ -5,7 +5,7 @@ export class bluebird<T> {
 
     static all: Array<bluebird<any>>;
 >all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0))
 }
 
@@ -39,13 +39,13 @@ export async function runSampleWorks<A, B, C, D, E>(
 >bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
 >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0))
 >all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
->[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(declarationEmitPromise.ts, 4, 52))
 >b : Symbol(b, Decl(declarationEmitPromise.ts, 5, 19))
 >c : Symbol(c, Decl(declarationEmitPromise.ts, 5, 36))
 >d : Symbol(d, Decl(declarationEmitPromise.ts, 5, 53))
 >e : Symbol(e, Decl(declarationEmitPromise.ts, 5, 70))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68))
 
@@ -67,9 +67,9 @@ export async function runSampleWorks<A, B, C, D, E>(
 >T : Symbol(T, Decl(declarationEmitPromise.ts, 7, 16))
 
         f.apply(this, result);
->f.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>f.apply : Symbol(Function.apply, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(declarationEmitPromise.ts, 7, 19))
->apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>apply : Symbol(Function.apply, Decl(lib.es6.d.ts, --, --))
 >result : Symbol(result, Decl(declarationEmitPromise.ts, 6, 7))
 
     let rfunc: typeof func & {} = func as any; // <- This is the only difference
@@ -111,13 +111,13 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
 >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0))
 >all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
->[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(declarationEmitPromise.ts, 13, 53))
 >b : Symbol(b, Decl(declarationEmitPromise.ts, 14, 19))
 >c : Symbol(c, Decl(declarationEmitPromise.ts, 14, 36))
 >d : Symbol(d, Decl(declarationEmitPromise.ts, 14, 53))
 >e : Symbol(e, Decl(declarationEmitPromise.ts, 14, 70))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68))
 
@@ -139,9 +139,9 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >T : Symbol(T, Decl(declarationEmitPromise.ts, 16, 16))
 
         f.apply(this, result);
->f.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>f.apply : Symbol(Function.apply, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(declarationEmitPromise.ts, 16, 19))
->apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>apply : Symbol(Function.apply, Decl(lib.es6.d.ts, --, --))
 >result : Symbol(result, Decl(declarationEmitPromise.ts, 15, 7))
 
     let rfunc: typeof func = func as any; // <- This is the only difference
diff --git a/tests/baselines/reference/declarationFiles.symbols b/tests/baselines/reference/declarationFiles.symbols
index e45b01d58dc..d8623676e49 100644
--- a/tests/baselines/reference/declarationFiles.symbols
+++ b/tests/baselines/reference/declarationFiles.symbols
@@ -44,11 +44,11 @@ class C3 {
 
     c: this | Date;
 >c : Symbol(C3.c, Decl(declarationFiles.ts, 17, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d: this & Date;
 >d : Symbol(C3.d, Decl(declarationFiles.ts, 18, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     e: (((this)));
 >e : Symbol(C3.e, Decl(declarationFiles.ts, 19, 19))
diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols
index 3e7ec568927..829635323dd 100644
--- a/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols
+++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/moduleExportsAmd/a.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
@@ -12,7 +12,7 @@ export default class Foo {}
 === tests/cases/conformance/es6/moduleExportsAmd/b.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols
index 383d7d2c0d2..a65cf169cbc 100644
--- a/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols
+++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/moduleExportsCommonjs/a.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
@@ -12,7 +12,7 @@ export default class Foo {}
 === tests/cases/conformance/es6/moduleExportsCommonjs/b.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols
index 73898da76c4..7358191e399 100644
--- a/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols
+++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/moduleExportsSystem/a.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
@@ -12,7 +12,7 @@ export default class Foo {}
 === tests/cases/conformance/es6/moduleExportsSystem/b.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
diff --git a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols
index f93e5411306..1bc810409af 100644
--- a/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols
+++ b/tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/moduleExportsUmd/a.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(a.ts, 0, 3))
@@ -12,7 +12,7 @@ export default class Foo {}
 === tests/cases/conformance/es6/moduleExportsUmd/b.ts ===
 var decorator: ClassDecorator;
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
->ClassDecorator : Symbol(ClassDecorator, Decl(lib.es5.d.ts, --, --))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.es6.d.ts, --, --))
 
 @decorator
 >decorator : Symbol(decorator, Decl(b.ts, 0, 3))
diff --git a/tests/baselines/reference/decoratorMetadataPromise.symbols b/tests/baselines/reference/decoratorMetadataPromise.symbols
index 4ec97538aa5..a40c240b38b 100644
--- a/tests/baselines/reference/decoratorMetadataPromise.symbols
+++ b/tests/baselines/reference/decoratorMetadataPromise.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/decoratorMetadataPromise.ts ===
 declare const decorator: MethodDecorator;
 >decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13))
->MethodDecorator : Symbol(MethodDecorator, Decl(lib.es5.d.ts, --, --))
+>MethodDecorator : Symbol(MethodDecorator, Decl(lib.es6.d.ts, --, --))
 
 class A {
 >A : Symbol(A, Decl(decoratorMetadataPromise.ts, 0, 41))
@@ -17,7 +17,7 @@ class A {
 
     async bar(): Promise<number> { return 0; }
 >bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 4, 18))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     @decorator
 >decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 0, 13))
@@ -25,8 +25,8 @@ class A {
     baz(n: Promise<number>): Promise<number> { return n; }
 >baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 6, 46))
 >n : Symbol(n, Decl(decoratorMetadataPromise.ts, 8, 8))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(decoratorMetadataPromise.ts, 8, 8))
 }
 
diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols b/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols
index 82fe1128ada..62b7f821c21 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols
+++ b/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassAccessor1.es6.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor1.es6.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor1.es6.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor1.es6.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor1.es6.ts, 0, 21))
 
 export default class {
diff --git a/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols b/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols
index 1e7707c5329..e57dcbaef54 100644
--- a/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod1.es6.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod1.es6.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod1.es6.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod1.es6.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod1.es6.ts, 0, 21))
 
 export default class {
diff --git a/tests/baselines/reference/decoratorOnClassMethod13.symbols b/tests/baselines/reference/decoratorOnClassMethod13.symbols
index 7cd369be144..2375932fbf1 100644
--- a/tests/baselines/reference/decoratorOnClassMethod13.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod13.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod13.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod13.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod13.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod4.symbols b/tests/baselines/reference/decoratorOnClassMethod4.symbols
index da0e9eafca7..c8c48aa2e4d 100644
--- a/tests/baselines/reference/decoratorOnClassMethod4.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod4.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod4.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod4.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod4.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod4.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod4.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod5.symbols b/tests/baselines/reference/decoratorOnClassMethod5.symbols
index bd895deeea8..fa523888fc4 100644
--- a/tests/baselines/reference/decoratorOnClassMethod5.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod5.symbols
@@ -5,9 +5,9 @@ declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedP
 >target : Symbol(target, Decl(decoratorOnClassMethod5.ts, 0, 28))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod5.ts, 0, 40))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod5.ts, 0, 61))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod5.ts, 0, 25))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod5.ts, 0, 25))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod6.symbols b/tests/baselines/reference/decoratorOnClassMethod6.symbols
index 6391192ece3..85f81d39af2 100644
--- a/tests/baselines/reference/decoratorOnClassMethod6.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod6.symbols
@@ -5,9 +5,9 @@ declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedP
 >target : Symbol(target, Decl(decoratorOnClassMethod6.ts, 0, 28))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod6.ts, 0, 40))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod6.ts, 0, 61))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod6.ts, 0, 25))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod6.ts, 0, 25))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod7.symbols b/tests/baselines/reference/decoratorOnClassMethod7.symbols
index 9ec0de0c205..bfdedcf0230 100644
--- a/tests/baselines/reference/decoratorOnClassMethod7.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod7.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod7.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod7.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod7.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod7.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod7.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols
index aee56f5a4f8..241d71d02d4 100644
--- a/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols
@@ -2,7 +2,7 @@
 declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void;
 >dec : Symbol(dec, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 0))
 >target : Symbol(target, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 21))
->Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 36))
 >parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 66))
 
diff --git a/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols b/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols
index b9c7be21514..57360209942 100644
--- a/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols
+++ b/tests/baselines/reference/decoratorWithUnderscoreMethod.symbols
@@ -6,13 +6,13 @@ declare var console : { log(arg: string): void };
 
 function dec(): Function {
 >dec : Symbol(dec, Decl(decoratorWithUnderscoreMethod.ts, 0, 49))
->Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     return function (target: any, propKey: string, descr: PropertyDescriptor): void {
 >target : Symbol(target, Decl(decoratorWithUnderscoreMethod.ts, 2, 21))
 >propKey : Symbol(propKey, Decl(decoratorWithUnderscoreMethod.ts, 2, 33))
 >descr : Symbol(descr, Decl(decoratorWithUnderscoreMethod.ts, 2, 50))
->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --))
+>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.es5.d.ts, --, --))
 
         console.log(target[propKey]);
 >console.log : Symbol(log, Decl(decoratorWithUnderscoreMethod.ts, 0, 23))
diff --git a/tests/baselines/reference/decoratorsOnComputedProperties.symbols b/tests/baselines/reference/decoratorsOnComputedProperties.symbols
index a9fb280f96e..614a18b82bd 100644
--- a/tests/baselines/reference/decoratorsOnComputedProperties.symbols
+++ b/tests/baselines/reference/decoratorsOnComputedProperties.symbols
@@ -3,7 +3,7 @@ function x(o: object, k: PropertyKey) { }
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
 >o : Symbol(o, Decl(decoratorsOnComputedProperties.ts, 0, 11))
 >k : Symbol(k, Decl(decoratorsOnComputedProperties.ts, 0, 21))
->PropertyKey : Symbol(PropertyKey, Decl(lib.es2015.core.d.ts, --, --))
+>PropertyKey : Symbol(PropertyKey, Decl(lib.es6.d.ts, --, --))
 
 let i = 0;
 >i : Symbol(i, Decl(decoratorsOnComputedProperties.ts, 1, 3))
@@ -30,9 +30,9 @@ class A {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -40,25 +40,25 @@ class A {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(A[["property3"]], Decl(decoratorsOnComputedProperties.ts, 12, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(A[["property4"]], Decl(decoratorsOnComputedProperties.ts, 14, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -92,9 +92,9 @@ void class B {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -102,25 +102,25 @@ void class B {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(B[["property3"]], Decl(decoratorsOnComputedProperties.ts, 29, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(B[["property4"]], Decl(decoratorsOnComputedProperties.ts, 31, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -155,9 +155,9 @@ class C {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -165,25 +165,25 @@ class C {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(C[["property3"]], Decl(decoratorsOnComputedProperties.ts, 46, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(C[["property4"]], Decl(decoratorsOnComputedProperties.ts, 48, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -219,9 +219,9 @@ void class D {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -229,25 +229,25 @@ void class D {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(D[["property3"]], Decl(decoratorsOnComputedProperties.ts, 64, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(D[["property4"]], Decl(decoratorsOnComputedProperties.ts, 66, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -283,9 +283,9 @@ class E {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -293,25 +293,25 @@ class E {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(E[["property3"]], Decl(decoratorsOnComputedProperties.ts, 82, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(E[["property4"]], Decl(decoratorsOnComputedProperties.ts, 84, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -346,9 +346,9 @@ void class F {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -356,25 +356,25 @@ void class F {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(F[["property3"]], Decl(decoratorsOnComputedProperties.ts, 100, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(F[["property4"]], Decl(decoratorsOnComputedProperties.ts, 102, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -410,9 +410,9 @@ class G {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -420,25 +420,25 @@ class G {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(G[["property3"]], Decl(decoratorsOnComputedProperties.ts, 118, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(G[["property4"]], Decl(decoratorsOnComputedProperties.ts, 120, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -474,9 +474,9 @@ void class H {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -484,25 +484,25 @@ void class H {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(H[["property3"]], Decl(decoratorsOnComputedProperties.ts, 137, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(H[["property4"]], Decl(decoratorsOnComputedProperties.ts, 139, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -539,9 +539,9 @@ class I {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -549,25 +549,25 @@ class I {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(I[["property3"]], Decl(decoratorsOnComputedProperties.ts, 156, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(I[["property4"]], Decl(decoratorsOnComputedProperties.ts, 158, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
@@ -605,9 +605,9 @@ void class J {
 
     @x [Symbol.toStringTag]: any;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     @x ["property2"]: any = 2;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
@@ -615,25 +615,25 @@ void class J {
 
     @x [Symbol.iterator]: any = null;
 >x : Symbol(x, Decl(decoratorsOnComputedProperties.ts, 0, 0))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     ["property3"]: any;
 >"property3" : Symbol(J[["property3"]], Decl(decoratorsOnComputedProperties.ts, 175, 37))
 
     [Symbol.isConcatSpreadable]: any;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     ["property4"]: any = 2;
 >"property4" : Symbol(J[["property4"]], Decl(decoratorsOnComputedProperties.ts, 177, 37))
 
     [Symbol.match]: any = null;
->Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->match : Symbol(SymbolConstructor.match, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>match : Symbol(SymbolConstructor.match, Decl(lib.es6.d.ts, --, --))
 
     [foo()]: any;
 >foo : Symbol(foo, Decl(decoratorsOnComputedProperties.ts, 1, 10))
diff --git a/tests/baselines/reference/deduplicateImportsInSystem.errors.txt b/tests/baselines/reference/deduplicateImportsInSystem.errors.txt
index d1bfe88160e..3ce3f88c817 100644
--- a/tests/baselines/reference/deduplicateImportsInSystem.errors.txt
+++ b/tests/baselines/reference/deduplicateImportsInSystem.errors.txt
@@ -4,10 +4,9 @@ tests/cases/compiler/deduplicateImportsInSystem.ts(3,17): error TS2307: Cannot f
 tests/cases/compiler/deduplicateImportsInSystem.ts(4,17): error TS2307: Cannot find module 'f2'.
 tests/cases/compiler/deduplicateImportsInSystem.ts(5,17): error TS2307: Cannot find module 'f2'.
 tests/cases/compiler/deduplicateImportsInSystem.ts(6,17): error TS2307: Cannot find module 'f1'.
-tests/cases/compiler/deduplicateImportsInSystem.ts(8,1): error TS2304: Cannot find name 'console'.
 
 
-==== tests/cases/compiler/deduplicateImportsInSystem.ts (7 errors) ====
+==== tests/cases/compiler/deduplicateImportsInSystem.ts (6 errors) ====
     import {A} from "f1";
                     ~~~~
 !!! error TS2307: Cannot find module 'f1'.
@@ -27,6 +26,4 @@ tests/cases/compiler/deduplicateImportsInSystem.ts(8,1): error TS2304: Cannot fi
                     ~~~~
 !!! error TS2307: Cannot find module 'f1'.
     
-    console.log(A + B + C + D + E + F)
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
\ No newline at end of file
+    console.log(A + B + C + D + E + F)
\ No newline at end of file
diff --git a/tests/baselines/reference/deduplicateImportsInSystem.symbols b/tests/baselines/reference/deduplicateImportsInSystem.symbols
index 3627df789db..93a4723a2b1 100644
--- a/tests/baselines/reference/deduplicateImportsInSystem.symbols
+++ b/tests/baselines/reference/deduplicateImportsInSystem.symbols
@@ -18,6 +18,9 @@ import {F} from 'f1';
 >F : Symbol(F, Decl(deduplicateImportsInSystem.ts, 5, 8))
 
 console.log(A + B + C + D + E + F)
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(deduplicateImportsInSystem.ts, 0, 8))
 >B : Symbol(B, Decl(deduplicateImportsInSystem.ts, 1, 8))
 >C : Symbol(C, Decl(deduplicateImportsInSystem.ts, 2, 8))
diff --git a/tests/baselines/reference/deduplicateImportsInSystem.types b/tests/baselines/reference/deduplicateImportsInSystem.types
index 07bfeb48639..8a0eb6430b4 100644
--- a/tests/baselines/reference/deduplicateImportsInSystem.types
+++ b/tests/baselines/reference/deduplicateImportsInSystem.types
@@ -18,10 +18,10 @@ import {F} from 'f1';
 >F : any
 
 console.log(A + B + C + D + E + F)
->console.log(A + B + C + D + E + F) : any
->console.log : any
->console : any
->log : any
+>console.log(A + B + C + D + E + F) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >A + B + C + D + E + F : any
 >A + B + C + D + E : any
 >A + B + C + D : any
diff --git a/tests/baselines/reference/defaultExportInAwaitExpression01.symbols b/tests/baselines/reference/defaultExportInAwaitExpression01.symbols
index 2741f624cff..ed135aa28ea 100644
--- a/tests/baselines/reference/defaultExportInAwaitExpression01.symbols
+++ b/tests/baselines/reference/defaultExportInAwaitExpression01.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/modules/a.ts ===
 const x = new Promise( ( resolve, reject ) => { resolve( {} ); } );
 >x : Symbol(x, Decl(a.ts, 0, 5))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
 >reject : Symbol(reject, Decl(a.ts, 0, 33))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
diff --git a/tests/baselines/reference/defaultExportInAwaitExpression02.symbols b/tests/baselines/reference/defaultExportInAwaitExpression02.symbols
index 2741f624cff..ed135aa28ea 100644
--- a/tests/baselines/reference/defaultExportInAwaitExpression02.symbols
+++ b/tests/baselines/reference/defaultExportInAwaitExpression02.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/modules/a.ts ===
 const x = new Promise( ( resolve, reject ) => { resolve( {} ); } );
 >x : Symbol(x, Decl(a.ts, 0, 5))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
 >reject : Symbol(reject, Decl(a.ts, 0, 33))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
diff --git a/tests/baselines/reference/derivedClassIncludesInheritedMembers.symbols b/tests/baselines/reference/derivedClassIncludesInheritedMembers.symbols
index 6cbc7a28707..1b9fcb27ea8 100644
--- a/tests/baselines/reference/derivedClassIncludesInheritedMembers.symbols
+++ b/tests/baselines/reference/derivedClassIncludesInheritedMembers.symbols
@@ -97,7 +97,7 @@ class Base2 {
 
     [x: number]: Date;
 >x : Symbol(x, Decl(derivedClassIncludesInheritedMembers.ts, 29, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class Derived2 extends Base2 {
diff --git a/tests/baselines/reference/derivedClassWithoutExplicitConstructor.symbols b/tests/baselines/reference/derivedClassWithoutExplicitConstructor.symbols
index 4340247ea88..32b4e16d942 100644
--- a/tests/baselines/reference/derivedClassWithoutExplicitConstructor.symbols
+++ b/tests/baselines/reference/derivedClassWithoutExplicitConstructor.symbols
@@ -52,7 +52,7 @@ class Base2<T> {
 class D<T extends Date> extends Base2<T> {
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor.ts, 16, 1))
 >T : Symbol(T, Decl(derivedClassWithoutExplicitConstructor.ts, 18, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base2 : Symbol(Base2, Decl(derivedClassWithoutExplicitConstructor.ts, 11, 24))
 >T : Symbol(T, Decl(derivedClassWithoutExplicitConstructor.ts, 18, 8))
 
@@ -71,5 +71,5 @@ var d = new D(); // error
 var d2 = new D(new Date()); // ok
 >d2 : Symbol(d2, Decl(derivedClassWithoutExplicitConstructor.ts, 24, 3))
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor.ts, 16, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/derivedClassWithoutExplicitConstructor2.symbols b/tests/baselines/reference/derivedClassWithoutExplicitConstructor2.symbols
index 0169094f97f..a6e3be7da95 100644
--- a/tests/baselines/reference/derivedClassWithoutExplicitConstructor2.symbols
+++ b/tests/baselines/reference/derivedClassWithoutExplicitConstructor2.symbols
@@ -83,7 +83,7 @@ class Base2<T> {
 class D<T extends Date> extends Base2<T> {
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor2.ts, 22, 1))
 >T : Symbol(T, Decl(derivedClassWithoutExplicitConstructor2.ts, 24, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base2 : Symbol(Base2, Decl(derivedClassWithoutExplicitConstructor2.ts, 15, 30))
 >T : Symbol(T, Decl(derivedClassWithoutExplicitConstructor2.ts, 24, 8))
 
@@ -102,18 +102,18 @@ var d = new D(); // error
 var d2 = new D(new Date()); // ok
 >d2 : Symbol(d2, Decl(derivedClassWithoutExplicitConstructor2.ts, 30, 3))
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor2.ts, 22, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var d3 = new D(new Date(), new Date());
 >d3 : Symbol(d3, Decl(derivedClassWithoutExplicitConstructor2.ts, 31, 3))
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor2.ts, 22, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var d4 = new D(new Date(), new Date(), new Date());
 >d4 : Symbol(d4, Decl(derivedClassWithoutExplicitConstructor2.ts, 32, 3))
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor2.ts, 22, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/derivedClassWithoutExplicitConstructor3.symbols b/tests/baselines/reference/derivedClassWithoutExplicitConstructor3.symbols
index d4cb0fb3b75..55e0c706427 100644
--- a/tests/baselines/reference/derivedClassWithoutExplicitConstructor3.symbols
+++ b/tests/baselines/reference/derivedClassWithoutExplicitConstructor3.symbols
@@ -107,7 +107,7 @@ class D<T> extends Base {
 class D2<T extends Date> extends D<T> {
 >D2 : Symbol(D2, Decl(derivedClassWithoutExplicitConstructor3.ts, 35, 1))
 >T : Symbol(T, Decl(derivedClassWithoutExplicitConstructor3.ts, 38, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >D : Symbol(D, Decl(derivedClassWithoutExplicitConstructor3.ts, 27, 1))
 >T : Symbol(T, Decl(derivedClassWithoutExplicitConstructor3.ts, 38, 9))
 
@@ -126,11 +126,11 @@ var d = new D2(); // error
 var d2 = new D2(new Date()); // error
 >d2 : Symbol(d2, Decl(derivedClassWithoutExplicitConstructor3.ts, 44, 3))
 >D2 : Symbol(D2, Decl(derivedClassWithoutExplicitConstructor3.ts, 35, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var d3 = new D2(new Date(), new Date()); // ok
 >d3 : Symbol(d3, Decl(derivedClassWithoutExplicitConstructor3.ts, 45, 3))
 >D2 : Symbol(D2, Decl(derivedClassWithoutExplicitConstructor3.ts, 35, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
index 3019439df54..d34aff88196 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
@@ -7,19 +7,19 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 6, 32))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 42))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
->Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
+>Number : Symbol(Number, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 function a1(...x: (number|string)[]) { }
 >a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 8, 45))
@@ -32,8 +32,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 11, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 12, 12))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 12, 36))
@@ -121,7 +121,7 @@ const enum E1 { a, b }
 function foo1<T extends Number>(...a: T[]) { }
 >foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 38, 22))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 39, 14))
->Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 39, 32))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 39, 14))
 
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
index 343febeee34..5656fb33597 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
@@ -7,19 +7,19 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 6, 32))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 42))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
->Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
+>Number : Symbol(Number, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 function a1(...x: (number|string)[]) { }
 >a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 8, 45))
@@ -32,8 +32,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 11, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 12, 12))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 12, 36))
@@ -121,7 +121,7 @@ const enum E1 { a, b }
 function foo1<T extends Number>(...a: T[]) { }
 >foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 38, 22))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 39, 14))
->Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 39, 32))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 39, 14))
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index af88159a9a4..d99227adb5f 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -3,9 +3,9 @@ function f() {
 >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 0, 0))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
 
         let arguments = 100;
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 2, 11))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index b87f113f7b2..14618f76ba1 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -6,9 +6,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 1, 7))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
 
         const arguments = 100;
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 3, 13))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index 3cc31438f74..077fde35fc5 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -6,9 +6,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 5, 7))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
 
         return () => arguments[0];
 >arguments : Symbol(arguments)
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index ecf7c9ba46a..f610cdbac25 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -7,9 +7,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 1, 25))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
 
         return () => arguments[0];
 >arguments : Symbol(arguments)
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index a10372c15d8..4599fdf9a6a 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -8,9 +8,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 1, 31))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es6.d.ts, --, --))
 
         return () => arguments;
 >arguments : Symbol(arguments)
diff --git a/tests/baselines/reference/enumAssignability.symbols b/tests/baselines/reference/enumAssignability.symbols
index f99dc85569e..b840b7addb0 100644
--- a/tests/baselines/reference/enumAssignability.symbols
+++ b/tests/baselines/reference/enumAssignability.symbols
@@ -84,7 +84,7 @@ module Others {
 
     var ee: Date = e;
 >ee : Symbol(ee, Decl(enumAssignability.ts, 30, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(enumAssignability.ts, 5, 3))
 
     var f: any = e; // ok
@@ -159,7 +159,7 @@ module Others {
 >U : Symbol(U, Decl(enumAssignability.ts, 46, 19))
 >T : Symbol(T, Decl(enumAssignability.ts, 46, 17))
 >V : Symbol(V, Decl(enumAssignability.ts, 46, 32))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(enumAssignability.ts, 46, 48))
 >Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(enumAssignability.ts, 46, 66))
diff --git a/tests/baselines/reference/enumAssignabilityInInheritance.symbols b/tests/baselines/reference/enumAssignabilityInInheritance.symbols
index 55071f3e14c..9d234c79622 100644
--- a/tests/baselines/reference/enumAssignabilityInInheritance.symbols
+++ b/tests/baselines/reference/enumAssignabilityInInheritance.symbols
@@ -85,8 +85,8 @@ var r4 = foo3(E.A);
 declare function foo4(x: Date): Date;
 >foo4 : Symbol(foo4, Decl(enumAssignabilityInInheritance.ts, 26, 19), Decl(enumAssignabilityInInheritance.ts, 28, 37))
 >x : Symbol(x, Decl(enumAssignabilityInInheritance.ts, 28, 22))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function foo4(x: E): E;
 >foo4 : Symbol(foo4, Decl(enumAssignabilityInInheritance.ts, 26, 19), Decl(enumAssignabilityInInheritance.ts, 28, 37))
diff --git a/tests/baselines/reference/enumConflictsWithGlobalIdentifier.errors.txt b/tests/baselines/reference/enumConflictsWithGlobalIdentifier.errors.txt
index e2ae62fe5e0..8501d6048e3 100644
--- a/tests/baselines/reference/enumConflictsWithGlobalIdentifier.errors.txt
+++ b/tests/baselines/reference/enumConflictsWithGlobalIdentifier.errors.txt
@@ -1,9 +1,13 @@
+tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(1,6): error TS2300: Duplicate identifier 'Position'.
 tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(4,9): error TS2304: Cannot find name 'IgnoreRulesSpecific'.
 tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(4,29): error TS1003: Identifier expected.
+tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(5,18): error TS2339: Property 'IgnoreRulesSpecific' does not exist on type '{ new (): Position; prototype: Position; }'.
 
 
-==== tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts (2 errors) ====
+==== tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts (4 errors) ====
     enum Position { 
+         ~~~~~~~~
+!!! error TS2300: Duplicate identifier 'Position'.
         IgnoreRulesSpecific = 0,
     }
     var x = IgnoreRulesSpecific.
@@ -12,4 +16,6 @@ tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(4,29): error TS1003: I
                                 
 !!! error TS1003: Identifier expected.
     var y = Position.IgnoreRulesSpecific;
+                     ~~~~~~~~~~~~~~~~~~~
+!!! error TS2339: Property 'IgnoreRulesSpecific' does not exist on type '{ new (): Position; prototype: Position; }'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/enumConflictsWithGlobalIdentifier.symbols b/tests/baselines/reference/enumConflictsWithGlobalIdentifier.symbols
index 0ca8ddaec8f..97ef34514bf 100644
--- a/tests/baselines/reference/enumConflictsWithGlobalIdentifier.symbols
+++ b/tests/baselines/reference/enumConflictsWithGlobalIdentifier.symbols
@@ -10,7 +10,5 @@ var x = IgnoreRulesSpecific.
 
 var y = Position.IgnoreRulesSpecific;
 >y : Symbol(y, Decl(enumConflictsWithGlobalIdentifier.ts, 4, 3))
->Position.IgnoreRulesSpecific : Symbol(Position.IgnoreRulesSpecific, Decl(enumConflictsWithGlobalIdentifier.ts, 0, 15))
->Position : Symbol(Position, Decl(enumConflictsWithGlobalIdentifier.ts, 0, 0))
->IgnoreRulesSpecific : Symbol(Position.IgnoreRulesSpecific, Decl(enumConflictsWithGlobalIdentifier.ts, 0, 15))
+>Position : Symbol(Position, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/enumConflictsWithGlobalIdentifier.types b/tests/baselines/reference/enumConflictsWithGlobalIdentifier.types
index b593384ac34..2c790e3f677 100644
--- a/tests/baselines/reference/enumConflictsWithGlobalIdentifier.types
+++ b/tests/baselines/reference/enumConflictsWithGlobalIdentifier.types
@@ -13,8 +13,8 @@ var x = IgnoreRulesSpecific.
 
 var y = Position.IgnoreRulesSpecific;
 > : any
->y : Position
->Position.IgnoreRulesSpecific : Position
->Position : typeof Position
->IgnoreRulesSpecific : Position
+>y : any
+>Position.IgnoreRulesSpecific : any
+>Position : { new (): Position; prototype: Position; }
+>IgnoreRulesSpecific : any
 
diff --git a/tests/baselines/reference/enumErrors.errors.txt b/tests/baselines/reference/enumErrors.errors.txt
index af719d47ae2..a0681ae3441 100644
--- a/tests/baselines/reference/enumErrors.errors.txt
+++ b/tests/baselines/reference/enumErrors.errors.txt
@@ -5,7 +5,7 @@ tests/cases/conformance/enums/enumErrors.ts(5,6): error TS2431: Enum name cannot
 tests/cases/conformance/enums/enumErrors.ts(9,9): error TS2322: Type 'Number' is not assignable to type 'E5'.
 tests/cases/conformance/enums/enumErrors.ts(26,9): error TS2322: Type 'true' is not assignable to type 'E11'.
 tests/cases/conformance/enums/enumErrors.ts(27,9): error TS2322: Type 'Date' is not assignable to type 'E11'.
-tests/cases/conformance/enums/enumErrors.ts(28,9): error TS2304: Cannot find name 'window'.
+tests/cases/conformance/enums/enumErrors.ts(28,9): error TS2322: Type 'Window' is not assignable to type 'E11'.
 tests/cases/conformance/enums/enumErrors.ts(29,9): error TS2322: Type '{}' is not assignable to type 'E11'.
 tests/cases/conformance/enums/enumErrors.ts(35,9): error TS2553: Computed values are not permitted in an enum with string valued members.
 tests/cases/conformance/enums/enumErrors.ts(36,9): error TS2553: Computed values are not permitted in an enum with string valued members.
@@ -57,7 +57,7 @@ tests/cases/conformance/enums/enumErrors.ts(38,9): error TS2553: Computed values
 !!! error TS2322: Type 'Date' is not assignable to type 'E11'.
         C = window,
             ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
+!!! error TS2322: Type 'Window' is not assignable to type 'E11'.
         D = {}
             ~~
 !!! error TS2322: Type '{}' is not assignable to type 'E11'.
diff --git a/tests/baselines/reference/enumErrors.symbols b/tests/baselines/reference/enumErrors.symbols
index e5c3bbd9519..e619debdcc9 100644
--- a/tests/baselines/reference/enumErrors.symbols
+++ b/tests/baselines/reference/enumErrors.symbols
@@ -59,10 +59,11 @@ enum E11 {
 
     B = new Date(),
 >B : Symbol(E11.B, Decl(enumErrors.ts, 25, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     C = window,
 >C : Symbol(E11.C, Decl(enumErrors.ts, 26, 19))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 
     D = {}
 >D : Symbol(E11.D, Decl(enumErrors.ts, 27, 15))
@@ -77,10 +78,11 @@ enum E12 {
 
     B = new Date(),
 >B : Symbol(E12.B, Decl(enumErrors.ts, 33, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     C = window,
 >C : Symbol(E12.C, Decl(enumErrors.ts, 34, 19))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 
     D = {},
 >D : Symbol(E12.D, Decl(enumErrors.ts, 35, 15))
diff --git a/tests/baselines/reference/enumErrors.types b/tests/baselines/reference/enumErrors.types
index 92fc77c24f4..8c95ef133ce 100644
--- a/tests/baselines/reference/enumErrors.types
+++ b/tests/baselines/reference/enumErrors.types
@@ -67,7 +67,7 @@ enum E11 {
 
     C = window,
 >C : E11
->window : any
+>window : Window
 
     D = {}
 >D : E11
@@ -89,7 +89,7 @@ enum E12 {
 
     C = window,
 >C : E12.B
->window : any
+>window : Window
 
     D = {},
 >D : E12.B
diff --git a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.symbols b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.symbols
index 8bae380a0f2..f8abda0c663 100644
--- a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.symbols
+++ b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.symbols
@@ -58,7 +58,7 @@ interface I5 {
 
     [x: string]: Date;
 >x : Symbol(x, Decl(enumIsNotASubtypeOfAnythingButNumber.ts, 28, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: E;
 >foo : Symbol(I5.foo, Decl(enumIsNotASubtypeOfAnythingButNumber.ts, 28, 22))
diff --git a/tests/baselines/reference/es6ClassTest2.errors.txt b/tests/baselines/reference/es6ClassTest2.errors.txt
index 0b68e1cd784..17d9d41ed03 100644
--- a/tests/baselines/reference/es6ClassTest2.errors.txt
+++ b/tests/baselines/reference/es6ClassTest2.errors.txt
@@ -1,9 +1,8 @@
-tests/cases/compiler/es6ClassTest2.ts(17,1): error TS2304: Cannot find name 'console'.
 tests/cases/compiler/es6ClassTest2.ts(30,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/es6ClassTest2.ts(35,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 
 
-==== tests/cases/compiler/es6ClassTest2.ts (3 errors) ====
+==== tests/cases/compiler/es6ClassTest2.ts (2 errors) ====
     class BasicMonster {
         constructor(public name: string, public health: number) {
     
@@ -21,8 +20,6 @@ tests/cases/compiler/es6ClassTest2.ts(35,9): error TS1056: Accessors are only av
     m1.attack(m2);
     m1.health = 0;
     console.log((<any>m5.isAlive).toString());
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
     
     class GetSetMonster {
         constructor(public name: string, private _health: number) {
diff --git a/tests/baselines/reference/es6ClassTest2.symbols b/tests/baselines/reference/es6ClassTest2.symbols
index 7ff2bced387..0b74e237f93 100644
--- a/tests/baselines/reference/es6ClassTest2.symbols
+++ b/tests/baselines/reference/es6ClassTest2.symbols
@@ -39,6 +39,9 @@ m1.health = 0;
 >health : Symbol(BasicMonster.health, Decl(es6ClassTest2.ts, 1, 36))
 
 console.log((<any>m5.isAlive).toString());
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >m5.isAlive : Symbol(OverloadedMonster.isAlive, Decl(es6ClassTest2.ts, 58, 5))
 >m5 : Symbol(m5, Decl(es6ClassTest2.ts, 63, 3))
 >isAlive : Symbol(OverloadedMonster.isAlive, Decl(es6ClassTest2.ts, 58, 5))
diff --git a/tests/baselines/reference/es6ClassTest2.types b/tests/baselines/reference/es6ClassTest2.types
index 2b2b5688d2a..8f1332f46ef 100644
--- a/tests/baselines/reference/es6ClassTest2.types
+++ b/tests/baselines/reference/es6ClassTest2.types
@@ -49,10 +49,10 @@ m1.health = 0;
 >0 : 0
 
 console.log((<any>m5.isAlive).toString());
->console.log((<any>m5.isAlive).toString()) : any
->console.log : any
->console : any
->log : any
+>console.log((<any>m5.isAlive).toString()) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >(<any>m5.isAlive).toString() : any
 >(<any>m5.isAlive).toString : any
 >(<any>m5.isAlive) : any
diff --git a/tests/baselines/reference/everyTypeAssignableToAny.symbols b/tests/baselines/reference/everyTypeAssignableToAny.symbols
index caf8c5e47d6..b60eac61eea 100644
--- a/tests/baselines/reference/everyTypeAssignableToAny.symbols
+++ b/tests/baselines/reference/everyTypeAssignableToAny.symbols
@@ -41,7 +41,7 @@ var d: boolean;
 
 var e: Date;
 >e : Symbol(e, Decl(everyTypeAssignableToAny.ts, 17, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f: any;
 >f : Symbol(f, Decl(everyTypeAssignableToAny.ts, 18, 3))
@@ -166,7 +166,7 @@ function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(everyTypeAssignableToAny.ts, 50, 13))
 >U : Symbol(U, Decl(everyTypeAssignableToAny.ts, 50, 15))
 >V : Symbol(V, Decl(everyTypeAssignableToAny.ts, 50, 32))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(everyTypeAssignableToAny.ts, 50, 49))
 >T : Symbol(T, Decl(everyTypeAssignableToAny.ts, 50, 13))
 >y : Symbol(y, Decl(everyTypeAssignableToAny.ts, 50, 54))
diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
index 8667507fb51..1b6661bca75 100644
--- a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
@@ -64,8 +64,8 @@ var aString: string = 'this is a string';
 
 var aDate: Date = new Date(12);
 >aDate : Symbol(aDate, Decl(everyTypeWithAnnotationAndInitializer.ts, 26, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anObject: Object = new Object();
 >anObject : Symbol(anObject, Decl(everyTypeWithAnnotationAndInitializer.ts, 27, 3))
diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.symbols b/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.symbols
index 9d85b954eb1..c5a734bd035 100644
--- a/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.symbols
@@ -87,7 +87,7 @@ var aString: string = 9.9;
 
 var aDate: Date = 9.9;
 >aDate : Symbol(aDate, Decl(everyTypeWithAnnotationAndInvalidInitializer.ts, 35, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var aVoid: void = 9.9;
 >aVoid : Symbol(aVoid, Decl(everyTypeWithAnnotationAndInvalidInitializer.ts, 37, 3))
diff --git a/tests/baselines/reference/everyTypeWithInitializer.symbols b/tests/baselines/reference/everyTypeWithInitializer.symbols
index ba269fbc536..1dacfcf8855 100644
--- a/tests/baselines/reference/everyTypeWithInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithInitializer.symbols
@@ -64,7 +64,7 @@ var aString = 'this is a string';
 
 var aDate = new Date(12);
 >aDate : Symbol(aDate, Decl(everyTypeWithInitializer.ts, 26, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anObject = new Object();
 >anObject : Symbol(anObject, Decl(everyTypeWithInitializer.ts, 27, 3))
diff --git a/tests/baselines/reference/excessPropertyCheckWithEmptyObject.errors.txt b/tests/baselines/reference/excessPropertyCheckWithEmptyObject.errors.txt
index 296493043b2..9399cfa7d1a 100644
--- a/tests/baselines/reference/excessPropertyCheckWithEmptyObject.errors.txt
+++ b/tests/baselines/reference/excessPropertyCheckWithEmptyObject.errors.txt
@@ -1,4 +1,3 @@
-tests/cases/compiler/excessPropertyCheckWithEmptyObject.ts(4,23): error TS2304: Cannot find name 'window'.
 tests/cases/compiler/excessPropertyCheckWithEmptyObject.ts(4,58): error TS2345: Argument of type '{ value: string; readonly: boolean; }' is not assignable to parameter of type 'PropertyDescriptor & ThisType<any>'.
   Object literal may only specify known properties, and 'readonly' does not exist in type 'PropertyDescriptor & ThisType<any>'.
 tests/cases/compiler/excessPropertyCheckWithEmptyObject.ts(9,30): error TS2322: Type '{ y: number; }' is not assignable to type 'A & ThisType<any>'.
@@ -7,13 +6,11 @@ tests/cases/compiler/excessPropertyCheckWithEmptyObject.ts(14,34): error TS2322:
   Object literal may only specify known properties, and 'y' does not exist in type 'Empty & { x: number; }'.
 
 
-==== tests/cases/compiler/excessPropertyCheckWithEmptyObject.ts (4 errors) ====
+==== tests/cases/compiler/excessPropertyCheckWithEmptyObject.ts (3 errors) ====
     // Repro from #14910
     
     // Excess property error expected here
     Object.defineProperty(window, "prop", { value: "v1.0.0", readonly: false });
-                          ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
                                                              ~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ value: string; readonly: boolean; }' is not assignable to parameter of type 'PropertyDescriptor & ThisType<any>'.
 !!! error TS2345:   Object literal may only specify known properties, and 'readonly' does not exist in type 'PropertyDescriptor & ThisType<any>'.
diff --git a/tests/baselines/reference/excessPropertyCheckWithEmptyObject.symbols b/tests/baselines/reference/excessPropertyCheckWithEmptyObject.symbols
index 2b6b5d90428..522fd81ffd1 100644
--- a/tests/baselines/reference/excessPropertyCheckWithEmptyObject.symbols
+++ b/tests/baselines/reference/excessPropertyCheckWithEmptyObject.symbols
@@ -6,6 +6,7 @@ Object.defineProperty(window, "prop", { value: "v1.0.0", readonly: false });
 >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 >value : Symbol(value, Decl(excessPropertyCheckWithEmptyObject.ts, 3, 39))
 >readonly : Symbol(readonly, Decl(excessPropertyCheckWithEmptyObject.ts, 3, 56))
 
diff --git a/tests/baselines/reference/excessPropertyCheckWithEmptyObject.types b/tests/baselines/reference/excessPropertyCheckWithEmptyObject.types
index ecf15c74da5..40eb1c45c82 100644
--- a/tests/baselines/reference/excessPropertyCheckWithEmptyObject.types
+++ b/tests/baselines/reference/excessPropertyCheckWithEmptyObject.types
@@ -7,7 +7,7 @@ Object.defineProperty(window, "prop", { value: "v1.0.0", readonly: false });
 >Object.defineProperty : (o: any, p: string, attributes: PropertyDescriptor & ThisType<any>) => any
 >Object : ObjectConstructor
 >defineProperty : (o: any, p: string, attributes: PropertyDescriptor & ThisType<any>) => any
->window : any
+>window : Window
 >"prop" : "prop"
 >{ value: "v1.0.0", readonly: false } : { value: string; readonly: boolean; }
 >value : string
diff --git a/tests/baselines/reference/exportAssignNonIdentifier.symbols b/tests/baselines/reference/exportAssignNonIdentifier.symbols
index f0826b78286..544af42713f 100644
--- a/tests/baselines/reference/exportAssignNonIdentifier.symbols
+++ b/tests/baselines/reference/exportAssignNonIdentifier.symbols
@@ -24,7 +24,7 @@ export = void; // Error, void operator requires an argument
 No type information for this code.
 No type information for this code.=== tests/cases/conformance/externalModules/foo7.ts ===
 export = Date || String; // Ok
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 === tests/cases/conformance/externalModules/foo8.ts ===
diff --git a/tests/baselines/reference/exportAssignValueAndType.symbols b/tests/baselines/reference/exportAssignValueAndType.symbols
index 3d5495b4874..c245c75f474 100644
--- a/tests/baselines/reference/exportAssignValueAndType.symbols
+++ b/tests/baselines/reference/exportAssignValueAndType.symbols
@@ -16,7 +16,7 @@ interface server {
 
     startTime: Date;
 >startTime : Symbol(server.startTime, Decl(exportAssignValueAndType.ts, 5, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
  
 var x = 5;
@@ -24,7 +24,7 @@ var x = 5;
 
 var server = new Date();
 >server : Symbol(server, Decl(exportAssignValueAndType.ts, 2, 1), Decl(exportAssignValueAndType.ts, 10, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 export = server;
 >server : Symbol(server, Decl(exportAssignValueAndType.ts, 2, 1), Decl(exportAssignValueAndType.ts, 10, 3))
diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols
index c383b8fd9e0..4085bff9c75 100644
--- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols
+++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols
@@ -12,7 +12,7 @@ interface x {
 >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0))
 
     (): Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: string;
 >foo : Symbol(x.foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 1, 13))
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction.symbols b/tests/baselines/reference/exportDefaultAsyncFunction.symbols
index 3b65dbc0245..2dce64af76d 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction.symbols
+++ b/tests/baselines/reference/exportDefaultAsyncFunction.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/exportDefaultAsyncFunction.ts ===
 export default async function foo(): Promise<void> {}
 >foo : Symbol(foo, Decl(exportDefaultAsyncFunction.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 foo();
 >foo : Symbol(foo, Decl(exportDefaultAsyncFunction.ts, 0, 0))
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
index 9816f3120a1..5e120c23259 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
@@ -16,9 +16,9 @@ import { async, await } from 'asyncawait';
 export default async(() => await(Promise.resolve(1)));
 >async : Symbol(async, Decl(a.ts, 0, 8))
 >await : Symbol(await, Decl(a.ts, 0, 15))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 === tests/cases/compiler/b.ts ===
 export default async () => { return 0; };
diff --git a/tests/baselines/reference/exportEqualErrorType.symbols b/tests/baselines/reference/exportEqualErrorType.symbols
index 16f50f4fff3..72c9d60661b 100644
--- a/tests/baselines/reference/exportEqualErrorType.symbols
+++ b/tests/baselines/reference/exportEqualErrorType.symbols
@@ -40,7 +40,7 @@ var server: {
 
     foo: Date;
 >foo : Symbol(foo, Decl(exportEqualErrorType_0.ts, 9, 29))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
 export = server;
diff --git a/tests/baselines/reference/exportEqualMemberMissing.symbols b/tests/baselines/reference/exportEqualMemberMissing.symbols
index fe5b3d47945..0347033840f 100644
--- a/tests/baselines/reference/exportEqualMemberMissing.symbols
+++ b/tests/baselines/reference/exportEqualMemberMissing.symbols
@@ -40,7 +40,7 @@ var server: {
 
     foo: Date;
 >foo : Symbol(foo, Decl(exportEqualMemberMissing_0.ts, 9, 29))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
 export = server;
diff --git a/tests/baselines/reference/exportEqualNamespaces.symbols b/tests/baselines/reference/exportEqualNamespaces.symbols
index 0c2890b028a..50061d55eb2 100644
--- a/tests/baselines/reference/exportEqualNamespaces.symbols
+++ b/tests/baselines/reference/exportEqualNamespaces.symbols
@@ -16,7 +16,7 @@ interface server {
 
     startTime: Date;
 >startTime : Symbol(server.startTime, Decl(exportEqualNamespaces.ts, 5, 22))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
  
 var x = 5;
@@ -24,7 +24,7 @@ var x = 5;
 
 var server = new Date();
 >server : Symbol(server, Decl(exportEqualNamespaces.ts, 0, 0), Decl(exportEqualNamespaces.ts, 2, 1), Decl(exportEqualNamespaces.ts, 10, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 export = server;
 >server : Symbol(server, Decl(exportEqualNamespaces.ts, 0, 0), Decl(exportEqualNamespaces.ts, 2, 1), Decl(exportEqualNamespaces.ts, 10, 3))
diff --git a/tests/baselines/reference/expressionTypeNodeShouldError.errors.txt b/tests/baselines/reference/expressionTypeNodeShouldError.errors.txt
index 86a592779ca..625f065d8cd 100644
--- a/tests/baselines/reference/expressionTypeNodeShouldError.errors.txt
+++ b/tests/baselines/reference/expressionTypeNodeShouldError.errors.txt
@@ -2,15 +2,12 @@ tests/cases/compiler/base.d.ts(1,23): error TS1005: ',' expected.
 tests/cases/compiler/base.d.ts(1,34): error TS1005: '=' expected.
 tests/cases/compiler/boolean.ts(7,23): error TS1005: ',' expected.
 tests/cases/compiler/boolean.ts(7,24): error TS1134: Variable declaration expected.
-tests/cases/compiler/boolean.ts(11,16): error TS2304: Cannot find name 'document'.
 tests/cases/compiler/boolean.ts(12,22): error TS1005: ';' expected.
 tests/cases/compiler/number.ts(7,26): error TS1005: ',' expected.
 tests/cases/compiler/number.ts(7,27): error TS1134: Variable declaration expected.
-tests/cases/compiler/number.ts(11,16): error TS2304: Cannot find name 'document'.
 tests/cases/compiler/number.ts(12,20): error TS1005: ';' expected.
 tests/cases/compiler/string.ts(7,20): error TS1005: ',' expected.
 tests/cases/compiler/string.ts(7,21): error TS1134: Variable declaration expected.
-tests/cases/compiler/string.ts(11,15): error TS2304: Cannot find name 'document'.
 tests/cases/compiler/string.ts(12,19): error TS1005: ';' expected.
 
 
@@ -21,7 +18,7 @@ tests/cases/compiler/string.ts(12,19): error TS1005: ';' expected.
                                      ~
 !!! error TS1005: '=' expected.
     
-==== tests/cases/compiler/string.ts (4 errors) ====
+==== tests/cases/compiler/string.ts (3 errors) ====
     interface String {
         typeof<T>(x: T): T;
     }
@@ -37,13 +34,11 @@ tests/cases/compiler/string.ts(12,19): error TS1005: ';' expected.
     }
     
     const nodes = document.getElementsByTagName("li");
-                  ~~~~~~~~
-!!! error TS2304: Cannot find name 'document'.
     type ItemType = "".typeof(nodes.item(0));
                       ~
 !!! error TS1005: ';' expected.
     
-==== tests/cases/compiler/number.ts (4 errors) ====
+==== tests/cases/compiler/number.ts (3 errors) ====
     interface Number {
         typeof<T>(x: T): T;
     }
@@ -59,13 +54,11 @@ tests/cases/compiler/string.ts(12,19): error TS1005: ';' expected.
     }
     
     const nodes2 = document.getElementsByTagName("li");
-                   ~~~~~~~~
-!!! error TS2304: Cannot find name 'document'.
     type ItemType2 = 4..typeof(nodes.item(0));
                        ~
 !!! error TS1005: ';' expected.
     
-==== tests/cases/compiler/boolean.ts (4 errors) ====
+==== tests/cases/compiler/boolean.ts (3 errors) ====
     interface Boolean {
         typeof<T>(x: T): T;
     }
@@ -81,8 +74,6 @@ tests/cases/compiler/string.ts(12,19): error TS1005: ';' expected.
     }
     
     const nodes3 = document.getElementsByTagName("li");
-                   ~~~~~~~~
-!!! error TS2304: Cannot find name 'document'.
     type ItemType3 = true.typeof(nodes.item(0));
                          ~
 !!! error TS1005: ';' expected.
diff --git a/tests/baselines/reference/expressionTypeNodeShouldError.symbols b/tests/baselines/reference/expressionTypeNodeShouldError.symbols
index 8cf752b1cfa..871a4035b93 100644
--- a/tests/baselines/reference/expressionTypeNodeShouldError.symbols
+++ b/tests/baselines/reference/expressionTypeNodeShouldError.symbols
@@ -31,10 +31,15 @@ class C {
 
 const nodes = document.getElementsByTagName("li");
 >nodes : Symbol(nodes, Decl(string.ts, 10, 5))
+>document.getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>document : Symbol(document, Decl(lib.d.ts, --, --))
+>getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type ItemType = "".typeof(nodes.item(0));
 >ItemType : Symbol(ItemType, Decl(string.ts, 10, 50))
+>nodes.item : Symbol(NodeListOf.item, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(string.ts, 10, 5))
+>item : Symbol(NodeListOf.item, Decl(lib.d.ts, --, --))
 
 === tests/cases/compiler/number.ts ===
 interface Number {
@@ -64,10 +69,15 @@ class C2 {
 
 const nodes2 = document.getElementsByTagName("li");
 >nodes2 : Symbol(nodes2, Decl(number.ts, 10, 5))
+>document.getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>document : Symbol(document, Decl(lib.d.ts, --, --))
+>getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type ItemType2 = 4..typeof(nodes.item(0));
 >ItemType2 : Symbol(ItemType2, Decl(number.ts, 10, 51))
+>nodes.item : Symbol(NodeListOf.item, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(string.ts, 10, 5))
+>item : Symbol(NodeListOf.item, Decl(lib.d.ts, --, --))
 
 === tests/cases/compiler/boolean.ts ===
 interface Boolean {
@@ -97,9 +107,14 @@ class C3 {
 
 const nodes3 = document.getElementsByTagName("li");
 >nodes3 : Symbol(nodes3, Decl(boolean.ts, 10, 5))
+>document.getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>document : Symbol(document, Decl(lib.d.ts, --, --))
+>getElementsByTagName : Symbol(Document.getElementsByTagName, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type ItemType3 = true.typeof(nodes.item(0));
 >ItemType3 : Symbol(ItemType3, Decl(boolean.ts, 10, 51))
+>nodes.item : Symbol(NodeListOf.item, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(string.ts, 10, 5))
+>item : Symbol(NodeListOf.item, Decl(lib.d.ts, --, --))
 
 
diff --git a/tests/baselines/reference/expressionTypeNodeShouldError.types b/tests/baselines/reference/expressionTypeNodeShouldError.types
index 67a44d061d1..bcf2386ae72 100644
--- a/tests/baselines/reference/expressionTypeNodeShouldError.types
+++ b/tests/baselines/reference/expressionTypeNodeShouldError.types
@@ -34,21 +34,21 @@ class C {
 }
 
 const nodes = document.getElementsByTagName("li");
->nodes : any
->document.getElementsByTagName("li") : any
->document.getElementsByTagName : any
->document : any
->getElementsByTagName : any
+>nodes : NodeListOf<HTMLLIElement>
+>document.getElementsByTagName("li") : NodeListOf<HTMLLIElement>
+>document.getElementsByTagName : { <K extends "symbol" | "object" | "abbr" | "acronym" | "address" | "article" | "aside" | "b" | "bdo" | "big" | "center" | "circle" | "cite" | "clippath" | "code" | "dd" | "defs" | "desc" | "dfn" | "dt" | "ellipse" | "em" | "feblend" | "fecolormatrix" | "fecomponenttransfer" | "fecomposite" | "feconvolvematrix" | "fediffuselighting" | "fedisplacementmap" | "fedistantlight" | "feflood" | "fefunca" | "fefuncb" | "fefuncg" | "fefuncr" | "fegaussianblur" | "feimage" | "femerge" | "femergenode" | "femorphology" | "feoffset" | "fepointlight" | "fespecularlighting" | "fespotlight" | "fetile" | "feturbulence" | "figcaption" | "figure" | "filter" | "footer" | "foreignobject" | "g" | "header" | "hgroup" | "i" | "image" | "kbd" | "keygen" | "line" | "lineargradient" | "mark" | "marker" | "mask" | "metadata" | "nav" | "nobr" | "noframes" | "noscript" | "path" | "pattern" | "plaintext" | "polygon" | "polyline" | "radialgradient" | "rect" | "rt" | "ruby" | "s" | "samp" | "section" | "small" | "stop" | "strike" | "strong" | "sub" | "sup" | "svg" | "switch" | "text" | "textpath" | "tspan" | "tt" | "u" | "use" | "var" | "view" | "wbr" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "canvas" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "div" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "span" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagname: K): ElementListTagNameMap[K]; (tagname: string): NodeListOf<Element>; }
+>document : Document
+>getElementsByTagName : { <K extends "symbol" | "object" | "abbr" | "acronym" | "address" | "article" | "aside" | "b" | "bdo" | "big" | "center" | "circle" | "cite" | "clippath" | "code" | "dd" | "defs" | "desc" | "dfn" | "dt" | "ellipse" | "em" | "feblend" | "fecolormatrix" | "fecomponenttransfer" | "fecomposite" | "feconvolvematrix" | "fediffuselighting" | "fedisplacementmap" | "fedistantlight" | "feflood" | "fefunca" | "fefuncb" | "fefuncg" | "fefuncr" | "fegaussianblur" | "feimage" | "femerge" | "femergenode" | "femorphology" | "feoffset" | "fepointlight" | "fespecularlighting" | "fespotlight" | "fetile" | "feturbulence" | "figcaption" | "figure" | "filter" | "footer" | "foreignobject" | "g" | "header" | "hgroup" | "i" | "image" | "kbd" | "keygen" | "line" | "lineargradient" | "mark" | "marker" | "mask" | "metadata" | "nav" | "nobr" | "noframes" | "noscript" | "path" | "pattern" | "plaintext" | "polygon" | "polyline" | "radialgradient" | "rect" | "rt" | "ruby" | "s" | "samp" | "section" | "small" | "stop" | "strike" | "strong" | "sub" | "sup" | "svg" | "switch" | "text" | "textpath" | "tspan" | "tt" | "u" | "use" | "var" | "view" | "wbr" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "canvas" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "div" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "span" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagname: K): ElementListTagNameMap[K]; (tagname: string): NodeListOf<Element>; }
 >"li" : "li"
 
 type ItemType = "".typeof(nodes.item(0));
 >ItemType : ""
 >typeof(nodes.item(0)) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
->(nodes.item(0)) : any
->nodes.item(0) : any
->nodes.item : any
->nodes : any
->item : any
+>(nodes.item(0)) : HTMLLIElement
+>nodes.item(0) : HTMLLIElement
+>nodes.item : (index: number) => HTMLLIElement
+>nodes : NodeListOf<HTMLLIElement>
+>item : (index: number) => HTMLLIElement
 >0 : 0
 
 === tests/cases/compiler/number.ts ===
@@ -80,21 +80,21 @@ class C2 {
 }
 
 const nodes2 = document.getElementsByTagName("li");
->nodes2 : any
->document.getElementsByTagName("li") : any
->document.getElementsByTagName : any
->document : any
->getElementsByTagName : any
+>nodes2 : NodeListOf<HTMLLIElement>
+>document.getElementsByTagName("li") : NodeListOf<HTMLLIElement>
+>document.getElementsByTagName : { <K extends "symbol" | "object" | "abbr" | "acronym" | "address" | "article" | "aside" | "b" | "bdo" | "big" | "center" | "circle" | "cite" | "clippath" | "code" | "dd" | "defs" | "desc" | "dfn" | "dt" | "ellipse" | "em" | "feblend" | "fecolormatrix" | "fecomponenttransfer" | "fecomposite" | "feconvolvematrix" | "fediffuselighting" | "fedisplacementmap" | "fedistantlight" | "feflood" | "fefunca" | "fefuncb" | "fefuncg" | "fefuncr" | "fegaussianblur" | "feimage" | "femerge" | "femergenode" | "femorphology" | "feoffset" | "fepointlight" | "fespecularlighting" | "fespotlight" | "fetile" | "feturbulence" | "figcaption" | "figure" | "filter" | "footer" | "foreignobject" | "g" | "header" | "hgroup" | "i" | "image" | "kbd" | "keygen" | "line" | "lineargradient" | "mark" | "marker" | "mask" | "metadata" | "nav" | "nobr" | "noframes" | "noscript" | "path" | "pattern" | "plaintext" | "polygon" | "polyline" | "radialgradient" | "rect" | "rt" | "ruby" | "s" | "samp" | "section" | "small" | "stop" | "strike" | "strong" | "sub" | "sup" | "svg" | "switch" | "text" | "textpath" | "tspan" | "tt" | "u" | "use" | "var" | "view" | "wbr" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "canvas" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "div" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "span" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagname: K): ElementListTagNameMap[K]; (tagname: string): NodeListOf<Element>; }
+>document : Document
+>getElementsByTagName : { <K extends "symbol" | "object" | "abbr" | "acronym" | "address" | "article" | "aside" | "b" | "bdo" | "big" | "center" | "circle" | "cite" | "clippath" | "code" | "dd" | "defs" | "desc" | "dfn" | "dt" | "ellipse" | "em" | "feblend" | "fecolormatrix" | "fecomponenttransfer" | "fecomposite" | "feconvolvematrix" | "fediffuselighting" | "fedisplacementmap" | "fedistantlight" | "feflood" | "fefunca" | "fefuncb" | "fefuncg" | "fefuncr" | "fegaussianblur" | "feimage" | "femerge" | "femergenode" | "femorphology" | "feoffset" | "fepointlight" | "fespecularlighting" | "fespotlight" | "fetile" | "feturbulence" | "figcaption" | "figure" | "filter" | "footer" | "foreignobject" | "g" | "header" | "hgroup" | "i" | "image" | "kbd" | "keygen" | "line" | "lineargradient" | "mark" | "marker" | "mask" | "metadata" | "nav" | "nobr" | "noframes" | "noscript" | "path" | "pattern" | "plaintext" | "polygon" | "polyline" | "radialgradient" | "rect" | "rt" | "ruby" | "s" | "samp" | "section" | "small" | "stop" | "strike" | "strong" | "sub" | "sup" | "svg" | "switch" | "text" | "textpath" | "tspan" | "tt" | "u" | "use" | "var" | "view" | "wbr" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "canvas" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "div" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "span" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagname: K): ElementListTagNameMap[K]; (tagname: string): NodeListOf<Element>; }
 >"li" : "li"
 
 type ItemType2 = 4..typeof(nodes.item(0));
 >ItemType2 : 4
 >typeof(nodes.item(0)) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
->(nodes.item(0)) : any
->nodes.item(0) : any
->nodes.item : any
->nodes : any
->item : any
+>(nodes.item(0)) : HTMLLIElement
+>nodes.item(0) : HTMLLIElement
+>nodes.item : (index: number) => HTMLLIElement
+>nodes : NodeListOf<HTMLLIElement>
+>item : (index: number) => HTMLLIElement
 >0 : 0
 
 === tests/cases/compiler/boolean.ts ===
@@ -127,22 +127,22 @@ class C3 {
 }
 
 const nodes3 = document.getElementsByTagName("li");
->nodes3 : any
->document.getElementsByTagName("li") : any
->document.getElementsByTagName : any
->document : any
->getElementsByTagName : any
+>nodes3 : NodeListOf<HTMLLIElement>
+>document.getElementsByTagName("li") : NodeListOf<HTMLLIElement>
+>document.getElementsByTagName : { <K extends "symbol" | "object" | "abbr" | "acronym" | "address" | "article" | "aside" | "b" | "bdo" | "big" | "center" | "circle" | "cite" | "clippath" | "code" | "dd" | "defs" | "desc" | "dfn" | "dt" | "ellipse" | "em" | "feblend" | "fecolormatrix" | "fecomponenttransfer" | "fecomposite" | "feconvolvematrix" | "fediffuselighting" | "fedisplacementmap" | "fedistantlight" | "feflood" | "fefunca" | "fefuncb" | "fefuncg" | "fefuncr" | "fegaussianblur" | "feimage" | "femerge" | "femergenode" | "femorphology" | "feoffset" | "fepointlight" | "fespecularlighting" | "fespotlight" | "fetile" | "feturbulence" | "figcaption" | "figure" | "filter" | "footer" | "foreignobject" | "g" | "header" | "hgroup" | "i" | "image" | "kbd" | "keygen" | "line" | "lineargradient" | "mark" | "marker" | "mask" | "metadata" | "nav" | "nobr" | "noframes" | "noscript" | "path" | "pattern" | "plaintext" | "polygon" | "polyline" | "radialgradient" | "rect" | "rt" | "ruby" | "s" | "samp" | "section" | "small" | "stop" | "strike" | "strong" | "sub" | "sup" | "svg" | "switch" | "text" | "textpath" | "tspan" | "tt" | "u" | "use" | "var" | "view" | "wbr" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "canvas" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "div" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "span" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagname: K): ElementListTagNameMap[K]; (tagname: string): NodeListOf<Element>; }
+>document : Document
+>getElementsByTagName : { <K extends "symbol" | "object" | "abbr" | "acronym" | "address" | "article" | "aside" | "b" | "bdo" | "big" | "center" | "circle" | "cite" | "clippath" | "code" | "dd" | "defs" | "desc" | "dfn" | "dt" | "ellipse" | "em" | "feblend" | "fecolormatrix" | "fecomponenttransfer" | "fecomposite" | "feconvolvematrix" | "fediffuselighting" | "fedisplacementmap" | "fedistantlight" | "feflood" | "fefunca" | "fefuncb" | "fefuncg" | "fefuncr" | "fegaussianblur" | "feimage" | "femerge" | "femergenode" | "femorphology" | "feoffset" | "fepointlight" | "fespecularlighting" | "fespotlight" | "fetile" | "feturbulence" | "figcaption" | "figure" | "filter" | "footer" | "foreignobject" | "g" | "header" | "hgroup" | "i" | "image" | "kbd" | "keygen" | "line" | "lineargradient" | "mark" | "marker" | "mask" | "metadata" | "nav" | "nobr" | "noframes" | "noscript" | "path" | "pattern" | "plaintext" | "polygon" | "polyline" | "radialgradient" | "rect" | "rt" | "ruby" | "s" | "samp" | "section" | "small" | "stop" | "strike" | "strong" | "sub" | "sup" | "svg" | "switch" | "text" | "textpath" | "tspan" | "tt" | "u" | "use" | "var" | "view" | "wbr" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "canvas" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "div" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "span" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagname: K): ElementListTagNameMap[K]; (tagname: string): NodeListOf<Element>; }
 >"li" : "li"
 
 type ItemType3 = true.typeof(nodes.item(0));
 >ItemType3 : true
 >true : true
 >typeof(nodes.item(0)) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
->(nodes.item(0)) : any
->nodes.item(0) : any
->nodes.item : any
->nodes : any
->item : any
+>(nodes.item(0)) : HTMLLIElement
+>nodes.item(0) : HTMLLIElement
+>nodes.item : (index: number) => HTMLLIElement
+>nodes : NodeListOf<HTMLLIElement>
+>item : (index: number) => HTMLLIElement
 >0 : 0
 
 
diff --git a/tests/baselines/reference/fixSignatureCaching.errors.txt b/tests/baselines/reference/fixSignatureCaching.errors.txt
index 7a5c43c966e..32fb1ebaf5b 100644
--- a/tests/baselines/reference/fixSignatureCaching.errors.txt
+++ b/tests/baselines/reference/fixSignatureCaching.errors.txt
@@ -36,10 +36,6 @@ tests/cases/conformance/fixSignatureCaching.ts(634,36): error TS2339: Property '
 tests/cases/conformance/fixSignatureCaching.ts(635,18): error TS2339: Property 'findMatch' does not exist on type '{}'.
 tests/cases/conformance/fixSignatureCaching.ts(635,33): error TS2339: Property 'mobileDetectRules' does not exist on type '{}'.
 tests/cases/conformance/fixSignatureCaching.ts(638,10): error TS2339: Property 'getDeviceSmallerSide' does not exist on type '{}'.
-tests/cases/conformance/fixSignatureCaching.ts(639,16): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/fixSignatureCaching.ts(639,38): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/fixSignatureCaching.ts(640,13): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/fixSignatureCaching.ts(641,13): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/fixSignatureCaching.ts(704,18): error TS2339: Property 'prepareDetectionCache' does not exist on type '{}'.
 tests/cases/conformance/fixSignatureCaching.ts(734,18): error TS2339: Property 'prepareDetectionCache' does not exist on type '{}'.
 tests/cases/conformance/fixSignatureCaching.ts(783,18): error TS2339: Property 'prepareDetectionCache' does not exist on type '{}'.
@@ -54,8 +50,6 @@ tests/cases/conformance/fixSignatureCaching.ts(912,36): error TS2339: Property '
 tests/cases/conformance/fixSignatureCaching.ts(912,53): error TS2339: Property 'mobileDetectRules' does not exist on type '{}'.
 tests/cases/conformance/fixSignatureCaching.ts(941,33): error TS2339: Property 'isPhoneSized' does not exist on type '(userAgent: any, maxPhoneWidth: any) => void'.
 tests/cases/conformance/fixSignatureCaching.ts(952,42): error TS2339: Property 'mobileGrade' does not exist on type '{}'.
-tests/cases/conformance/fixSignatureCaching.ts(959,16): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/fixSignatureCaching.ts(959,42): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/fixSignatureCaching.ts(960,22): error TS2339: Property 'isPhoneSized' does not exist on type '(userAgent: any, maxPhoneWidth: any) => void'.
 tests/cases/conformance/fixSignatureCaching.ts(961,57): error TS2339: Property 'getDeviceSmallerSide' does not exist on type '{}'.
 tests/cases/conformance/fixSignatureCaching.ts(964,22): error TS2339: Property 'isPhoneSized' does not exist on type '(userAgent: any, maxPhoneWidth: any) => void'.
@@ -67,11 +61,10 @@ tests/cases/conformance/fixSignatureCaching.ts(976,37): error TS2304: Cannot fin
 tests/cases/conformance/fixSignatureCaching.ts(977,23): error TS2304: Cannot find name 'define'.
 tests/cases/conformance/fixSignatureCaching.ts(977,48): error TS2304: Cannot find name 'define'.
 tests/cases/conformance/fixSignatureCaching.ts(978,16): error TS2304: Cannot find name 'define'.
-tests/cases/conformance/fixSignatureCaching.ts(979,23): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/fixSignatureCaching.ts(980,37): error TS2304: Cannot find name 'window'.
+tests/cases/conformance/fixSignatureCaching.ts(980,44): error TS2339: Property 'MobileDetect' does not exist on type 'Window'.
 
 
-==== tests/cases/conformance/fixSignatureCaching.ts (71 errors) ====
+==== tests/cases/conformance/fixSignatureCaching.ts (64 errors) ====
     // Repro from #10697
     
     (function (define, undefined) {
@@ -787,16 +780,8 @@ tests/cases/conformance/fixSignatureCaching.ts(980,37): error TS2304: Cannot fin
              ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2339: Property 'getDeviceSmallerSide' does not exist on type '{}'.
             return window.screen.width < window.screen.height ?
-                   ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
-                                         ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
                 window.screen.width :
-                ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
                 window.screen.height;
-                ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
         };
     
         /**
@@ -1143,10 +1128,6 @@ tests/cases/conformance/fixSignatureCaching.ts(980,37): error TS2304: Cannot fin
     
         // environment-dependent
         if (typeof window !== 'undefined' && window.screen) {
-                   ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
-                                             ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
             MobileDetect.isPhoneSized = function (maxPhoneWidth) {
                          ~~~~~~~~~~~~
 !!! error TS2339: Property 'isPhoneSized' does not exist on type '(userAgent: any, maxPhoneWidth: any) => void'.
@@ -1189,11 +1170,9 @@ tests/cases/conformance/fixSignatureCaching.ts(980,37): error TS2304: Cannot fin
                    ~~~~~~
 !!! error TS2304: Cannot find name 'define'.
         } else if (typeof window !== 'undefined') {
-                          ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
             return function (factory) { window.MobileDetect = factory(); };
-                                        ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
+                                               ~~~~~~~~~~~~
+!!! error TS2339: Property 'MobileDetect' does not exist on type 'Window'.
         } else {
             // please file a bug if you get this error!
             throw new Error('unknown environment');
diff --git a/tests/baselines/reference/fixSignatureCaching.symbols b/tests/baselines/reference/fixSignatureCaching.symbols
index 40eb658fd68..041cd542cc6 100644
--- a/tests/baselines/reference/fixSignatureCaching.symbols
+++ b/tests/baselines/reference/fixSignatureCaching.symbols
@@ -1117,8 +1117,31 @@ define(function () {
 >impl : Symbol(impl, Decl(fixSignatureCaching.ts, 6, 7))
 
         return window.screen.width < window.screen.height ?
+>window.screen.width : Symbol(Screen.width, Decl(lib.d.ts, --, --))
+>window.screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>width : Symbol(Screen.width, Decl(lib.d.ts, --, --))
+>window.screen.height : Symbol(Screen.height, Decl(lib.d.ts, --, --))
+>window.screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>height : Symbol(Screen.height, Decl(lib.d.ts, --, --))
+
             window.screen.width :
+>window.screen.width : Symbol(Screen.width, Decl(lib.d.ts, --, --))
+>window.screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>width : Symbol(Screen.width, Decl(lib.d.ts, --, --))
+
             window.screen.height;
+>window.screen.height : Symbol(Screen.height, Decl(lib.d.ts, --, --))
+>window.screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>height : Symbol(Screen.height, Decl(lib.d.ts, --, --))
+
     };
 
     /**
@@ -1533,6 +1556,11 @@ define(function () {
 
     // environment-dependent
     if (typeof window !== 'undefined' && window.screen) {
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>window.screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+>screen : Symbol(Window.screen, Decl(lib.d.ts, --, --))
+
         MobileDetect.isPhoneSized = function (maxPhoneWidth) {
 >MobileDetect : Symbol(MobileDetect, Decl(fixSignatureCaching.ts, 641, 6))
 >maxPhoneWidth : Symbol(maxPhoneWidth, Decl(fixSignatureCaching.ts, 959, 46))
@@ -1572,8 +1600,11 @@ define(function () {
     } else if (typeof define === 'function' && define.amd) {
         return define;
     } else if (typeof window !== 'undefined') {
+>window : Symbol(window, Decl(lib.d.ts, --, --))
+
         return function (factory) { window.MobileDetect = factory(); };
 >factory : Symbol(factory, Decl(fixSignatureCaching.ts, 979, 25))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 >factory : Symbol(factory, Decl(fixSignatureCaching.ts, 979, 25))
 
     } else {
diff --git a/tests/baselines/reference/fixSignatureCaching.types b/tests/baselines/reference/fixSignatureCaching.types
index 781912544e2..4e9ed0d8d71 100644
--- a/tests/baselines/reference/fixSignatureCaching.types
+++ b/tests/baselines/reference/fixSignatureCaching.types
@@ -2457,39 +2457,39 @@ define(function () {
     };
 
     impl.getDeviceSmallerSide = function () {
->impl.getDeviceSmallerSide = function () {        return window.screen.width < window.screen.height ?            window.screen.width :            window.screen.height;    } : () => any
+>impl.getDeviceSmallerSide = function () {        return window.screen.width < window.screen.height ?            window.screen.width :            window.screen.height;    } : () => number
 >impl.getDeviceSmallerSide : any
 >impl : {}
 >getDeviceSmallerSide : any
->function () {        return window.screen.width < window.screen.height ?            window.screen.width :            window.screen.height;    } : () => any
+>function () {        return window.screen.width < window.screen.height ?            window.screen.width :            window.screen.height;    } : () => number
 
         return window.screen.width < window.screen.height ?
->window.screen.width < window.screen.height ?            window.screen.width :            window.screen.height : any
+>window.screen.width < window.screen.height ?            window.screen.width :            window.screen.height : number
 >window.screen.width < window.screen.height : boolean
->window.screen.width : any
->window.screen : any
->window : any
->screen : any
->width : any
->window.screen.height : any
->window.screen : any
->window : any
->screen : any
->height : any
+>window.screen.width : number
+>window.screen : Screen
+>window : Window
+>screen : Screen
+>width : number
+>window.screen.height : number
+>window.screen : Screen
+>window : Window
+>screen : Screen
+>height : number
 
             window.screen.width :
->window.screen.width : any
->window.screen : any
->window : any
->screen : any
->width : any
+>window.screen.width : number
+>window.screen : Screen
+>window : Window
+>screen : Screen
+>width : number
 
             window.screen.height;
->window.screen.height : any
->window.screen : any
->window : any
->screen : any
->height : any
+>window.screen.height : number
+>window.screen : Screen
+>window : Window
+>screen : Screen
+>height : number
 
     };
 
@@ -3158,14 +3158,14 @@ define(function () {
 
     // environment-dependent
     if (typeof window !== 'undefined' && window.screen) {
->typeof window !== 'undefined' && window.screen : any
+>typeof window !== 'undefined' && window.screen : Screen
 >typeof window !== 'undefined' : boolean
 >typeof window : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
->window : any
+>window : Window
 >'undefined' : "undefined"
->window.screen : any
->window : any
->screen : any
+>window.screen : Screen
+>window : Window
+>screen : Screen
 
         MobileDetect.isPhoneSized = function (maxPhoneWidth) {
 >MobileDetect.isPhoneSized = function (maxPhoneWidth) {            return maxPhoneWidth < 0 ? undefined : impl.getDeviceSmallerSide() <= maxPhoneWidth;        } : (maxPhoneWidth: any) => any
@@ -3259,7 +3259,7 @@ define(function () {
     } else if (typeof window !== 'undefined') {
 >typeof window !== 'undefined' : boolean
 >typeof window : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
->window : any
+>window : Window
 >'undefined' : "undefined"
 
         return function (factory) { window.MobileDetect = factory(); };
@@ -3267,7 +3267,7 @@ define(function () {
 >factory : any
 >window.MobileDetect = factory() : any
 >window.MobileDetect : any
->window : any
+>window : Window
 >MobileDetect : any
 >factory() : any
 >factory : any
diff --git a/tests/baselines/reference/for-inStatements.symbols b/tests/baselines/reference/for-inStatements.symbols
index e0c65d37535..04f3169fc4f 100644
--- a/tests/baselines/reference/for-inStatements.symbols
+++ b/tests/baselines/reference/for-inStatements.symbols
@@ -32,7 +32,7 @@ for (var x in /[a-z]/) { }
 
 for (var x in new Date()) { }
 >x : Symbol(x, Decl(for-inStatements.ts, 6, 8), Decl(for-inStatements.ts, 7, 8), Decl(for-inStatements.ts, 8, 8), Decl(for-inStatements.ts, 11, 8), Decl(for-inStatements.ts, 13, 8) ... and 14 more)
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var c: any, d: any, e: any;
 >c : Symbol(c, Decl(for-inStatements.ts, 16, 3))
diff --git a/tests/baselines/reference/for-inStatementsArray.symbols b/tests/baselines/reference/for-inStatementsArray.symbols
index 0d594c193cb..6e447f55086 100644
--- a/tests/baselines/reference/for-inStatementsArray.symbols
+++ b/tests/baselines/reference/for-inStatementsArray.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/statements/for-inStatements/for-inStatementsArray.ts ===
 let a: Date[];
 >a : Symbol(a, Decl(for-inStatementsArray.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 let b: boolean[];
 >b : Symbol(b, Decl(for-inStatementsArray.ts, 1, 3))
diff --git a/tests/baselines/reference/for-inStatementsArrayErrors.symbols b/tests/baselines/reference/for-inStatementsArrayErrors.symbols
index 506d7739a7e..b37ca0b3762 100644
--- a/tests/baselines/reference/for-inStatementsArrayErrors.symbols
+++ b/tests/baselines/reference/for-inStatementsArrayErrors.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/statements/for-inStatements/for-inStatementsArrayErrors.ts ===
 let a: Date[];
 >a : Symbol(a, Decl(for-inStatementsArrayErrors.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (let x in a) {
 >x : Symbol(x, Decl(for-inStatementsArrayErrors.ts, 2, 8))
diff --git a/tests/baselines/reference/for-of12.symbols b/tests/baselines/reference/for-of12.symbols
index 1e3b75da731..cdfca2893e7 100644
--- a/tests/baselines/reference/for-of12.symbols
+++ b/tests/baselines/reference/for-of12.symbols
@@ -4,6 +4,6 @@ var v: string;
 
 for (v of [0, ""].values()) { }
 >v : Symbol(v, Decl(for-of12.ts, 0, 3))
->[0, ""].values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --))
->values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --))
+>[0, ""].values : Symbol(Array.values, Decl(lib.es6.d.ts, --, --))
+>values : Symbol(Array.values, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols
index d257ed5290a..4bdf2315c0f 100644
--- a/tests/baselines/reference/for-of13.symbols
+++ b/tests/baselines/reference/for-of13.symbols
@@ -4,6 +4,6 @@ var v: string;
 
 for (v of [""].values()) { }
 >v : Symbol(v, Decl(for-of13.ts, 0, 3))
->[""].values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --))
->values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --))
+>[""].values : Symbol(Array.values, Decl(lib.es6.d.ts, --, --))
+>values : Symbol(Array.values, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/for-of15.symbols b/tests/baselines/reference/for-of15.symbols
index b2ca9c4f091..4436a759943 100644
--- a/tests/baselines/reference/for-of15.symbols
+++ b/tests/baselines/reference/for-of15.symbols
@@ -8,9 +8,9 @@ class StringIterator {
         return "";
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of15.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of16.symbols b/tests/baselines/reference/for-of16.symbols
index 9d3d1dee720..fb6ff42d748 100644
--- a/tests/baselines/reference/for-of16.symbols
+++ b/tests/baselines/reference/for-of16.symbols
@@ -3,9 +3,9 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of16.ts, 0, 0))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of16.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of17.symbols b/tests/baselines/reference/for-of17.symbols
index 506c9535ed7..15162ed375a 100644
--- a/tests/baselines/reference/for-of17.symbols
+++ b/tests/baselines/reference/for-of17.symbols
@@ -15,9 +15,9 @@ class NumberIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(NumberIterator, Decl(for-of17.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index 8f552c2757c..9e8129b8555 100644
--- a/tests/baselines/reference/for-of18.symbols
+++ b/tests/baselines/reference/for-of18.symbols
@@ -15,9 +15,9 @@ class StringIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of18.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols
index f36dd74f9b9..475e9bdef4d 100644
--- a/tests/baselines/reference/for-of19.symbols
+++ b/tests/baselines/reference/for-of19.symbols
@@ -19,9 +19,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of19.ts, 0, 13))
diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols
index 5fff9fd7871..135950b9906 100644
--- a/tests/baselines/reference/for-of20.symbols
+++ b/tests/baselines/reference/for-of20.symbols
@@ -19,9 +19,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of20.ts, 0, 13))
diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols
index 0068c9ef4a8..e0580b2309d 100644
--- a/tests/baselines/reference/for-of21.symbols
+++ b/tests/baselines/reference/for-of21.symbols
@@ -19,9 +19,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of21.ts, 0, 13))
diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols
index 929cae4ed77..ab5d5dc2979 100644
--- a/tests/baselines/reference/for-of22.symbols
+++ b/tests/baselines/reference/for-of22.symbols
@@ -19,9 +19,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of22.ts, 0, 13))
diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols
index 7a57e38baf7..1f3c2b7c16b 100644
--- a/tests/baselines/reference/for-of23.symbols
+++ b/tests/baselines/reference/for-of23.symbols
@@ -19,9 +19,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of23.ts, 0, 13))
diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols
index e9304e517bd..3f2a0d8173d 100644
--- a/tests/baselines/reference/for-of25.symbols
+++ b/tests/baselines/reference/for-of25.symbols
@@ -3,9 +3,9 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 0, 0))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return x;
 >x : Symbol(x, Decl(for-of25.ts, 6, 3))
diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols
index 20473898253..ae139558650 100644
--- a/tests/baselines/reference/for-of26.symbols
+++ b/tests/baselines/reference/for-of26.symbols
@@ -9,9 +9,9 @@ class StringIterator {
 >x : Symbol(x, Decl(for-of26.ts, 9, 3))
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of26.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols
index 4799a138351..994e2a74462 100644
--- a/tests/baselines/reference/for-of27.symbols
+++ b/tests/baselines/reference/for-of27.symbols
@@ -3,9 +3,9 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 0))
 
     [Symbol.iterator]: any;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 }
 
 for (var v of new StringIterator) { }
diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols
index ad5ea53a80e..c0f679b22e8 100644
--- a/tests/baselines/reference/for-of28.symbols
+++ b/tests/baselines/reference/for-of28.symbols
@@ -6,9 +6,9 @@ class StringIterator {
 >next : Symbol(StringIterator.next, Decl(for-of28.ts, 0, 22))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of29.symbols b/tests/baselines/reference/for-of29.symbols
index 8327d0ac855..fb15a02cc14 100644
--- a/tests/baselines/reference/for-of29.symbols
+++ b/tests/baselines/reference/for-of29.symbols
@@ -3,10 +3,10 @@ var iterableWithOptionalIterator: {
 >iterableWithOptionalIterator : Symbol(iterableWithOptionalIterator, Decl(for-of29.ts, 0, 3))
 
     [Symbol.iterator]?(): Iterator<string>
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
 
 };
 
diff --git a/tests/baselines/reference/for-of30.symbols b/tests/baselines/reference/for-of30.symbols
index 87620251110..dbe9c17eb71 100644
--- a/tests/baselines/reference/for-of30.symbols
+++ b/tests/baselines/reference/for-of30.symbols
@@ -18,9 +18,9 @@ class StringIterator {
 >return : Symbol(StringIterator.return, Decl(for-of30.ts, 6, 5))
     
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of30.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of31.symbols b/tests/baselines/reference/for-of31.symbols
index b5f999db49c..15900209a8d 100644
--- a/tests/baselines/reference/for-of31.symbols
+++ b/tests/baselines/reference/for-of31.symbols
@@ -13,9 +13,9 @@ class StringIterator {
     }
     
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of31.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of33.symbols b/tests/baselines/reference/for-of33.symbols
index e77d3b31c76..ecb4f6c48ea 100644
--- a/tests/baselines/reference/for-of33.symbols
+++ b/tests/baselines/reference/for-of33.symbols
@@ -3,9 +3,9 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of33.ts, 0, 0))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return v;
 >v : Symbol(v, Decl(for-of33.ts, 6, 8))
diff --git a/tests/baselines/reference/for-of34.symbols b/tests/baselines/reference/for-of34.symbols
index 864e250ad49..0587405edcb 100644
--- a/tests/baselines/reference/for-of34.symbols
+++ b/tests/baselines/reference/for-of34.symbols
@@ -10,9 +10,9 @@ class StringIterator {
     }
     
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of34.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of35.symbols b/tests/baselines/reference/for-of35.symbols
index b1f48ba3afb..1690a53ce7b 100644
--- a/tests/baselines/reference/for-of35.symbols
+++ b/tests/baselines/reference/for-of35.symbols
@@ -16,9 +16,9 @@ class StringIterator {
     }
     
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of35.ts, 0, 0))
diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols
index c9c5c627b8a..e89cd2107b7 100644
--- a/tests/baselines/reference/for-of37.symbols
+++ b/tests/baselines/reference/for-of37.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of37.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of37.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for (var v of map) {
 >v : Symbol(v, Decl(for-of37.ts, 1, 8))
diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols
index d1df1afea3b..6b2f3d5dfb2 100644
--- a/tests/baselines/reference/for-of38.symbols
+++ b/tests/baselines/reference/for-of38.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of38.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of38.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for (var [k, v] of map) {
 >k : Symbol(k, Decl(for-of38.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols
index 37fff144559..1fd88ab268d 100644
--- a/tests/baselines/reference/for-of40.symbols
+++ b/tests/baselines/reference/for-of40.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of40.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of40.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for (var [k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of40.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols
index fb951a6ef8a..3c1db7bf525 100644
--- a/tests/baselines/reference/for-of44.symbols
+++ b/tests/baselines/reference/for-of44.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of44.ts ===
 var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]]
 >array : Symbol(array, Decl(for-of44.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for (var [num, strBoolSym] of array) {
 >num : Symbol(num, Decl(for-of44.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols
index 3a0968069c8..02f0244d769 100644
--- a/tests/baselines/reference/for-of45.symbols
+++ b/tests/baselines/reference/for-of45.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of45.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of46.symbols b/tests/baselines/reference/for-of46.symbols
index c8ff2106f22..07c62839999 100644
--- a/tests/baselines/reference/for-of46.symbols
+++ b/tests/baselines/reference/for-of46.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of46.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for ([k = false, v = ""] of map) {
 >k : Symbol(k, Decl(for-of46.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of49.symbols b/tests/baselines/reference/for-of49.symbols
index 8d0c4b64255..043c81f6d88 100644
--- a/tests/baselines/reference/for-of49.symbols
+++ b/tests/baselines/reference/for-of49.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of49.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for ([k, ...[v]] of map) {
 >k : Symbol(k, Decl(for-of49.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols
index ad9b06d48a9..278ee0f852a 100644
--- a/tests/baselines/reference/for-of50.symbols
+++ b/tests/baselines/reference/for-of50.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of50.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of50.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 for (const [k, v] of map) {
 >k : Symbol(k, Decl(for-of50.ts, 1, 12))
diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols
index 7428ab54b83..5c5d18ec956 100644
--- a/tests/baselines/reference/for-of57.symbols
+++ b/tests/baselines/reference/for-of57.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of57.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(for-of57.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
 for (let num of iter) { }
 >num : Symbol(num, Decl(for-of57.ts, 1, 8))
diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols
index e775d615f36..be1ca79fbbc 100644
--- a/tests/baselines/reference/forStatements.symbols
+++ b/tests/baselines/reference/forStatements.symbols
@@ -64,8 +64,8 @@ for(var aString: string = 'this is a string';;){}
 
 for(var aDate: Date = new Date(12);;){}
 >aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for(var anObject: Object = new Object();;){}
 >anObject : Symbol(anObject, Decl(forStatements.ts, 27, 7))
diff --git a/tests/baselines/reference/functionCalls.errors.txt b/tests/baselines/reference/functionCalls.errors.txt
index 8e84aa81e0e..85e75876779 100644
--- a/tests/baselines/reference/functionCalls.errors.txt
+++ b/tests/baselines/reference/functionCalls.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(8,1): error TS2347: Untyped function calls may not accept type arguments.
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(9,1): error TS2347: Untyped function calls may not accept type arguments.
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(10,1): error TS2347: Untyped function calls may not accept type arguments.
-tests/cases/conformance/expressions/functionCalls/functionCalls.ts(10,8): error TS2304: Cannot find name 'Window'.
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(25,1): error TS2347: Untyped function calls may not accept type arguments.
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(26,1): error TS2347: Untyped function calls may not accept type arguments.
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(27,1): error TS2347: Untyped function calls may not accept type arguments.
@@ -10,7 +9,7 @@ tests/cases/conformance/expressions/functionCalls/functionCalls.ts(33,1): error
 tests/cases/conformance/expressions/functionCalls/functionCalls.ts(34,1): error TS2347: Untyped function calls may not accept type arguments.
 
 
-==== tests/cases/conformance/expressions/functionCalls/functionCalls.ts (10 errors) ====
+==== tests/cases/conformance/expressions/functionCalls/functionCalls.ts (9 errors) ====
     // Invoke function call on value of type 'any' with no type arguments
     var anyVar: any;
     anyVar(0);
@@ -27,8 +26,6 @@ tests/cases/conformance/expressions/functionCalls/functionCalls.ts(34,1): error
     anyVar<Window>(undefined);
     ~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2347: Untyped function calls may not accept type arguments.
-           ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     
     
     // Invoke function call on value of a subtype of Function with no call signatures with no type arguments
diff --git a/tests/baselines/reference/functionCalls.symbols b/tests/baselines/reference/functionCalls.symbols
index 34fbb1f6c39..1ecb8534cd2 100644
--- a/tests/baselines/reference/functionCalls.symbols
+++ b/tests/baselines/reference/functionCalls.symbols
@@ -19,6 +19,7 @@ anyVar<number>();
 
 anyVar<Window>(undefined);
 >anyVar : Symbol(anyVar, Decl(functionCalls.ts, 1, 3))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 
diff --git a/tests/baselines/reference/functionCalls.types b/tests/baselines/reference/functionCalls.types
index ac707188946..3b50d75aeb9 100644
--- a/tests/baselines/reference/functionCalls.types
+++ b/tests/baselines/reference/functionCalls.types
@@ -27,7 +27,7 @@ anyVar<number>();
 anyVar<Window>(undefined);
 >anyVar<Window>(undefined) : any
 >anyVar : any
->Window : No type information available!
+>Window : Window
 >undefined : undefined
 
 
diff --git a/tests/baselines/reference/functionConstraintSatisfaction.symbols b/tests/baselines/reference/functionConstraintSatisfaction.symbols
index 6c7ca5f7713..71f5b47707a 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction.symbols
+++ b/tests/baselines/reference/functionConstraintSatisfaction.symbols
@@ -154,7 +154,7 @@ var r11 = foo(<U extends Date>(x: U) => x);
 >r11 : Symbol(r11, Decl(functionConstraintSatisfaction.ts, 42, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31))
diff --git a/tests/baselines/reference/functionOverloadErrors.errors.txt b/tests/baselines/reference/functionOverloadErrors.errors.txt
index 1ec0344ac62..ddcaf478602 100644
--- a/tests/baselines/reference/functionOverloadErrors.errors.txt
+++ b/tests/baselines/reference/functionOverloadErrors.errors.txt
@@ -1,7 +1,4 @@
 tests/cases/conformance/functions/functionOverloadErrors.ts(2,14): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
-tests/cases/conformance/functions/functionOverloadErrors.ts(44,25): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/functions/functionOverloadErrors.ts(50,25): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/functions/functionOverloadErrors.ts(51,32): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/functions/functionOverloadErrors.ts(65,13): error TS2385: Overload signatures must all be public, private or protected.
 tests/cases/conformance/functions/functionOverloadErrors.ts(68,13): error TS2385: Overload signatures must all be public, private or protected.
 tests/cases/conformance/functions/functionOverloadErrors.ts(75,21): error TS2383: Overload signatures must all be exported or non-exported.
@@ -14,7 +11,7 @@ tests/cases/conformance/functions/functionOverloadErrors.ts(103,10): error TS239
 tests/cases/conformance/functions/functionOverloadErrors.ts(116,19): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
 
 
-==== tests/cases/conformance/functions/functionOverloadErrors.ts (14 errors) ====
+==== tests/cases/conformance/functions/functionOverloadErrors.ts (11 errors) ====
     //Function overload signature with initializer
     function fn1(x = 3);
                  ~~~~~
@@ -61,19 +58,13 @@ tests/cases/conformance/functions/functionOverloadErrors.ts(116,19): error TS237
     
     //Function overloads that differ only by type parameter constraints
     function fn10<T extends Window>();
-                            ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     function fn10<S extends Date>();
     function fn10() { }
     // (actually OK)
     
     //Function overloads that differ only by type parameter constraints where constraints are structually identical
     function fn11<T extends Window>();
-                            ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     function fn11<S extends typeof window>();
-                                   ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     function fn11() { }
     
     //Function overloads that differ only by type parameter constraints where constraints include infinitely recursive type reference
diff --git a/tests/baselines/reference/functionOverloadErrors.symbols b/tests/baselines/reference/functionOverloadErrors.symbols
index 8bfd05eb1b2..fe548f740c1 100644
--- a/tests/baselines/reference/functionOverloadErrors.symbols
+++ b/tests/baselines/reference/functionOverloadErrors.symbols
@@ -106,11 +106,12 @@ function fn9() { }
 function fn10<T extends Window>();
 >fn10 : Symbol(fn10, Decl(functionOverloadErrors.ts, 40, 18), Decl(functionOverloadErrors.ts, 43, 34), Decl(functionOverloadErrors.ts, 44, 32))
 >T : Symbol(T, Decl(functionOverloadErrors.ts, 43, 14))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn10<S extends Date>();
 >fn10 : Symbol(fn10, Decl(functionOverloadErrors.ts, 40, 18), Decl(functionOverloadErrors.ts, 43, 34), Decl(functionOverloadErrors.ts, 44, 32))
 >S : Symbol(S, Decl(functionOverloadErrors.ts, 44, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn10() { }
 >fn10 : Symbol(fn10, Decl(functionOverloadErrors.ts, 40, 18), Decl(functionOverloadErrors.ts, 43, 34), Decl(functionOverloadErrors.ts, 44, 32))
@@ -121,10 +122,12 @@ function fn10() { }
 function fn11<T extends Window>();
 >fn11 : Symbol(fn11, Decl(functionOverloadErrors.ts, 45, 19), Decl(functionOverloadErrors.ts, 49, 34), Decl(functionOverloadErrors.ts, 50, 41))
 >T : Symbol(T, Decl(functionOverloadErrors.ts, 49, 14))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn11<S extends typeof window>();
 >fn11 : Symbol(fn11, Decl(functionOverloadErrors.ts, 45, 19), Decl(functionOverloadErrors.ts, 49, 34), Decl(functionOverloadErrors.ts, 50, 41))
 >S : Symbol(S, Decl(functionOverloadErrors.ts, 50, 14))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 
 function fn11() { }
 >fn11 : Symbol(fn11, Decl(functionOverloadErrors.ts, 45, 19), Decl(functionOverloadErrors.ts, 49, 34), Decl(functionOverloadErrors.ts, 50, 41))
diff --git a/tests/baselines/reference/functionOverloadErrors.types b/tests/baselines/reference/functionOverloadErrors.types
index 3f056f36856..958a498e651 100644
--- a/tests/baselines/reference/functionOverloadErrors.types
+++ b/tests/baselines/reference/functionOverloadErrors.types
@@ -106,33 +106,33 @@ function fn9() { }
 
 //Function overloads that differ only by type parameter constraints
 function fn10<T extends Window>();
->fn10 : { <T extends any>(): any; <S extends Date>(): any; }
+>fn10 : { <T extends Window>(): any; <S extends Date>(): any; }
 >T : T
->Window : No type information available!
+>Window : Window
 
 function fn10<S extends Date>();
->fn10 : { <T extends any>(): any; <S extends Date>(): any; }
+>fn10 : { <T extends Window>(): any; <S extends Date>(): any; }
 >S : S
 >Date : Date
 
 function fn10() { }
->fn10 : { <T extends any>(): any; <S extends Date>(): any; }
+>fn10 : { <T extends Window>(): any; <S extends Date>(): any; }
 
 // (actually OK)
 
 //Function overloads that differ only by type parameter constraints where constraints are structually identical
 function fn11<T extends Window>();
->fn11 : { <T extends any>(): any; <S extends any>(): any; }
+>fn11 : { <T extends Window>(): any; <S extends Window>(): any; }
 >T : T
->Window : No type information available!
+>Window : Window
 
 function fn11<S extends typeof window>();
->fn11 : { <T extends any>(): any; <S extends any>(): any; }
+>fn11 : { <T extends Window>(): any; <S extends Window>(): any; }
 >S : S
->window : any
+>window : Window
 
 function fn11() { }
->fn11 : { <T extends any>(): any; <S extends any>(): any; }
+>fn11 : { <T extends Window>(): any; <S extends Window>(): any; }
 
 //Function overloads that differ only by type parameter constraints where constraints include infinitely recursive type reference
 interface List<T> {
diff --git a/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols b/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols
index 750da358d67..dd5ac297758 100644
--- a/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols
+++ b/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols
@@ -16,5 +16,5 @@ interface I {
 >U : Symbol(U, Decl(functionOverloadsOnGenericArity2.ts, 3, 9))
 >T : Symbol(T, Decl(functionOverloadsOnGenericArity2.ts, 3, 11))
 >p : Symbol(p, Decl(functionOverloadsOnGenericArity2.ts, 3, 15))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.errors.txt b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.errors.txt
index 2fa3cafcb1a..def0ff8811e 100644
--- a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.errors.txt
+++ b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.errors.txt
@@ -1,9 +1,8 @@
 tests/cases/compiler/functionTypeArgumentAssignmentCompat.ts(9,1): error TS2322: Type '<S>() => S[]' is not assignable to type '<T>(x: T) => T'.
   Type '{}[]' is not assignable to type 'T'.
-tests/cases/compiler/functionTypeArgumentAssignmentCompat.ts(12,1): error TS2304: Cannot find name 'console'.
 
 
-==== tests/cases/compiler/functionTypeArgumentAssignmentCompat.ts (2 errors) ====
+==== tests/cases/compiler/functionTypeArgumentAssignmentCompat.ts (1 errors) ====
     var f : {
      <T>(x:T): T;
     }
@@ -19,6 +18,4 @@ tests/cases/compiler/functionTypeArgumentAssignmentCompat.ts(12,1): error TS2304
     var s = f("str").toUpperCase();
     
     console.log(s);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.symbols b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.symbols
index 1ec90fb4970..afba235425d 100644
--- a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.symbols
+++ b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.symbols
@@ -29,5 +29,8 @@ var s = f("str").toUpperCase();
 >toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 
 console.log(s);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(functionTypeArgumentAssignmentCompat.ts, 9, 3))
 
diff --git a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types
index 2d072d6ec24..6b7f73c7eb6 100644
--- a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types
+++ b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types
@@ -35,9 +35,9 @@ var s = f("str").toUpperCase();
 >toUpperCase : () => string
 
 console.log(s);
->console.log(s) : any
->console.log : any
->console : any
->log : any
+>console.log(s) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >s : string
 
diff --git a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.errors.txt b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.errors.txt
deleted file mode 100644
index 4e60ceda6b5..00000000000
--- a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.errors.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-tests/cases/compiler/functionWithDefaultParameterWithNoStatements9.ts(1,18): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/functionWithDefaultParameterWithNoStatements9.ts(3,18): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/functionWithDefaultParameterWithNoStatements9.ts (2 errors) ====
-    function foo(a = console.log) { }
-                     ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    
-    function bar(a = console.log) {
-                     ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.symbols b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.symbols
index 879858d67ad..a6e0b70ba60 100644
--- a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.symbols
+++ b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.symbols
@@ -2,8 +2,14 @@
 function foo(a = console.log) { }
 >foo : Symbol(foo, Decl(functionWithDefaultParameterWithNoStatements9.ts, 0, 0))
 >a : Symbol(a, Decl(functionWithDefaultParameterWithNoStatements9.ts, 0, 13))
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 
 function bar(a = console.log) {
 >bar : Symbol(bar, Decl(functionWithDefaultParameterWithNoStatements9.ts, 0, 33))
 >a : Symbol(a, Decl(functionWithDefaultParameterWithNoStatements9.ts, 2, 13))
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.types b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.types
index 40dd9229315..4a22cafc486 100644
--- a/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.types
+++ b/tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.types
@@ -1,15 +1,15 @@
 === tests/cases/compiler/functionWithDefaultParameterWithNoStatements9.ts ===
 function foo(a = console.log) { }
->foo : (a?: any) => void
->a : any
->console.log : any
->console : any
->log : any
+>foo : (a?: (message?: any, ...optionalParams: any[]) => void) => void
+>a : (message?: any, ...optionalParams: any[]) => void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 
 function bar(a = console.log) {
->bar : (a?: any) => void
->a : any
->console.log : any
->console : any
->log : any
+>bar : (a?: (message?: any, ...optionalParams: any[]) => void) => void
+>a : (message?: any, ...optionalParams: any[]) => void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 }
diff --git a/tests/baselines/reference/generatorES6_6.symbols b/tests/baselines/reference/generatorES6_6.symbols
index e277757e98d..4b3fc684edc 100644
--- a/tests/baselines/reference/generatorES6_6.symbols
+++ b/tests/baselines/reference/generatorES6_6.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(generatorES6_6.ts, 0, 0))
 
   *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     let a = yield 1;
 >a : Symbol(a, Decl(generatorES6_6.ts, 2, 7))
diff --git a/tests/baselines/reference/generatorOverloads1.symbols b/tests/baselines/reference/generatorOverloads1.symbols
index 38215c2a343..7497f051332 100644
--- a/tests/baselines/reference/generatorOverloads1.symbols
+++ b/tests/baselines/reference/generatorOverloads1.symbols
@@ -5,15 +5,15 @@ module M {
     function* f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads1.ts, 0, 10), Decl(generatorOverloads1.ts, 1, 42), Decl(generatorOverloads1.ts, 2, 42))
 >s : Symbol(s, Decl(generatorOverloads1.ts, 1, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     function* f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads1.ts, 0, 10), Decl(generatorOverloads1.ts, 1, 42), Decl(generatorOverloads1.ts, 2, 42))
 >s : Symbol(s, Decl(generatorOverloads1.ts, 2, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     function* f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads1.ts, 0, 10), Decl(generatorOverloads1.ts, 1, 42), Decl(generatorOverloads1.ts, 2, 42))
 >s : Symbol(s, Decl(generatorOverloads1.ts, 3, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorOverloads2.symbols b/tests/baselines/reference/generatorOverloads2.symbols
index 9a80182cf0a..184e4832e16 100644
--- a/tests/baselines/reference/generatorOverloads2.symbols
+++ b/tests/baselines/reference/generatorOverloads2.symbols
@@ -5,15 +5,15 @@ declare module M {
     function* f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads2.ts, 0, 18), Decl(generatorOverloads2.ts, 1, 42), Decl(generatorOverloads2.ts, 2, 42))
 >s : Symbol(s, Decl(generatorOverloads2.ts, 1, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     function* f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads2.ts, 0, 18), Decl(generatorOverloads2.ts, 1, 42), Decl(generatorOverloads2.ts, 2, 42))
 >s : Symbol(s, Decl(generatorOverloads2.ts, 2, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     function* f(s: any): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads2.ts, 0, 18), Decl(generatorOverloads2.ts, 1, 42), Decl(generatorOverloads2.ts, 2, 42))
 >s : Symbol(s, Decl(generatorOverloads2.ts, 3, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorOverloads3.symbols b/tests/baselines/reference/generatorOverloads3.symbols
index 2fdf8c56580..ca2f704e9e9 100644
--- a/tests/baselines/reference/generatorOverloads3.symbols
+++ b/tests/baselines/reference/generatorOverloads3.symbols
@@ -5,15 +5,15 @@ class C {
     *f(s: string): Iterable<any>;
 >f : Symbol(C.f, Decl(generatorOverloads3.ts, 0, 9), Decl(generatorOverloads3.ts, 1, 33), Decl(generatorOverloads3.ts, 2, 33))
 >s : Symbol(s, Decl(generatorOverloads3.ts, 1, 7))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     *f(s: number): Iterable<any>;
 >f : Symbol(C.f, Decl(generatorOverloads3.ts, 0, 9), Decl(generatorOverloads3.ts, 1, 33), Decl(generatorOverloads3.ts, 2, 33))
 >s : Symbol(s, Decl(generatorOverloads3.ts, 2, 7))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     *f(s: any): Iterable<any> { }
 >f : Symbol(C.f, Decl(generatorOverloads3.ts, 0, 9), Decl(generatorOverloads3.ts, 1, 33), Decl(generatorOverloads3.ts, 2, 33))
 >s : Symbol(s, Decl(generatorOverloads3.ts, 3, 7))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorOverloads4.symbols b/tests/baselines/reference/generatorOverloads4.symbols
index f7ab5bc1f95..7fa2608d65a 100644
--- a/tests/baselines/reference/generatorOverloads4.symbols
+++ b/tests/baselines/reference/generatorOverloads4.symbols
@@ -5,15 +5,15 @@ class C {
     f(s: string): Iterable<any>;
 >f : Symbol(C.f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     f(s: number): Iterable<any>;
 >f : Symbol(C.f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     *f(s: any): Iterable<any> { }
 >f : Symbol(C.f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorOverloads5.symbols b/tests/baselines/reference/generatorOverloads5.symbols
index feb27cabed0..e99fd377d6d 100644
--- a/tests/baselines/reference/generatorOverloads5.symbols
+++ b/tests/baselines/reference/generatorOverloads5.symbols
@@ -5,15 +5,15 @@ module M {
     function f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     function f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
     function* f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols
index dbb6db06833..efcdb8215ae 100644
--- a/tests/baselines/reference/generatorTypeCheck1.symbols
+++ b/tests/baselines/reference/generatorTypeCheck1.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
 function* g1(): Iterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck10.symbols b/tests/baselines/reference/generatorTypeCheck10.symbols
index 3d6f8cf889a..50f56a8c82e 100644
--- a/tests/baselines/reference/generatorTypeCheck10.symbols
+++ b/tests/baselines/reference/generatorTypeCheck10.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts ===
 function* g(): IterableIterator<any> {
 >g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 
     return;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols
index aea1ffd781c..923a9b5c880 100644
--- a/tests/baselines/reference/generatorTypeCheck11.symbols
+++ b/tests/baselines/reference/generatorTypeCheck11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 
     return 0;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols
index 2dc7d5d42ab..b9145c00fdd 100644
--- a/tests/baselines/reference/generatorTypeCheck12.symbols
+++ b/tests/baselines/reference/generatorTypeCheck12.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 
     return "";
 }
diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols
index 494356185c8..0ca8616dfc3 100644
--- a/tests/baselines/reference/generatorTypeCheck13.symbols
+++ b/tests/baselines/reference/generatorTypeCheck13.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 
     yield 0;
     return "";
diff --git a/tests/baselines/reference/generatorTypeCheck17.symbols b/tests/baselines/reference/generatorTypeCheck17.symbols
index 6e4941dd7cf..099f0b415c8 100644
--- a/tests/baselines/reference/generatorTypeCheck17.symbols
+++ b/tests/baselines/reference/generatorTypeCheck17.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck18.symbols b/tests/baselines/reference/generatorTypeCheck18.symbols
index 103f3c4e48a..87157a10fe5 100644
--- a/tests/baselines/reference/generatorTypeCheck18.symbols
+++ b/tests/baselines/reference/generatorTypeCheck18.symbols
@@ -9,7 +9,7 @@ class Baz { z: number }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck18.ts, 1, 23))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck18.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck19.symbols b/tests/baselines/reference/generatorTypeCheck19.symbols
index bb72f4b5646..d9cf5ea03e4 100644
--- a/tests/baselines/reference/generatorTypeCheck19.symbols
+++ b/tests/baselines/reference/generatorTypeCheck19.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck2.symbols b/tests/baselines/reference/generatorTypeCheck2.symbols
index 33c0200c0c9..e092a3a939c 100644
--- a/tests/baselines/reference/generatorTypeCheck2.symbols
+++ b/tests/baselines/reference/generatorTypeCheck2.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts ===
 function* g1(): Iterable<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck20.symbols b/tests/baselines/reference/generatorTypeCheck20.symbols
index b82c2e64b80..34f0e8f625c 100644
--- a/tests/baselines/reference/generatorTypeCheck20.symbols
+++ b/tests/baselines/reference/generatorTypeCheck20.symbols
@@ -9,7 +9,7 @@ class Baz { z: number }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck20.ts, 1, 23))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck20.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck21.symbols b/tests/baselines/reference/generatorTypeCheck21.symbols
index d7a8c1fb131..0d36624402d 100644
--- a/tests/baselines/reference/generatorTypeCheck21.symbols
+++ b/tests/baselines/reference/generatorTypeCheck21.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck21.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck21.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck25.symbols b/tests/baselines/reference/generatorTypeCheck25.symbols
index ebbe92062ed..8cafe9e8849 100644
--- a/tests/baselines/reference/generatorTypeCheck25.symbols
+++ b/tests/baselines/reference/generatorTypeCheck25.symbols
@@ -14,7 +14,7 @@ class Baz { z: number }
 
 var g3: () => Iterable<Foo> = function* () {
 >g3 : Symbol(g3, Decl(generatorTypeCheck25.ts, 3, 3))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck25.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols
index b5f5a65669e..78cc075c76f 100644
--- a/tests/baselines/reference/generatorTypeCheck26.symbols
+++ b/tests/baselines/reference/generatorTypeCheck26.symbols
@@ -1,20 +1,20 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
 
     yield x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
     yield *[x => x.length];
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
     return x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols
index 58f5e562423..82e142b15c3 100644
--- a/tests/baselines/reference/generatorTypeCheck27.symbols
+++ b/tests/baselines/reference/generatorTypeCheck27.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
 
     yield * function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols
index c07d0819244..8f3b9f96948 100644
--- a/tests/baselines/reference/generatorTypeCheck28.symbols
+++ b/tests/baselines/reference/generatorTypeCheck28.symbols
@@ -1,20 +1,20 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
 
     yield * {
         *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
             yield x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
         }
     };
 }
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
index 5ea31ccb0cd..8f0304c0874 100644
--- a/tests/baselines/reference/generatorTypeCheck29.symbols
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck3.symbols b/tests/baselines/reference/generatorTypeCheck3.symbols
index 4533e1d9d2f..6bd083eb812 100644
--- a/tests/baselines/reference/generatorTypeCheck3.symbols
+++ b/tests/baselines/reference/generatorTypeCheck3.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts ===
 function* g1(): IterableIterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
index f1626cf067f..76e02c243cf 100644
--- a/tests/baselines/reference/generatorTypeCheck30.symbols
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck31.symbols b/tests/baselines/reference/generatorTypeCheck31.symbols
index 2cdc507cd7f..ede40291591 100644
--- a/tests/baselines/reference/generatorTypeCheck31.symbols
+++ b/tests/baselines/reference/generatorTypeCheck31.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts ===
 function* g2(): Iterator<() => Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck31.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck31.ts, 0, 41))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
index fa8cdacfcd3..893b642cb99 100644
--- a/tests/baselines/reference/generatorTypeCheck45.symbols
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
@@ -19,9 +19,9 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
 >foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(generatorTypeCheck45.ts, 2, 45))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols
index e2a10557c86..c0aa592d486 100644
--- a/tests/baselines/reference/generatorTypeCheck46.symbols
+++ b/tests/baselines/reference/generatorTypeCheck46.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))
@@ -21,15 +21,15 @@ foo("", function* () {
 
     yield* {
         *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
             yield x => x.length
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>x.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
         }
     }
 }, p => undefined); // T is fixed, should be string
diff --git a/tests/baselines/reference/generatorTypeCheck62.symbols b/tests/baselines/reference/generatorTypeCheck62.symbols
index b8eb11d1f67..ab07de3d4f4 100644
--- a/tests/baselines/reference/generatorTypeCheck62.symbols
+++ b/tests/baselines/reference/generatorTypeCheck62.symbols
@@ -14,11 +14,11 @@ export function strategy<T extends StrategicState>(stratName: string, gen: (a: T
 >gen : Symbol(gen, Decl(generatorTypeCheck62.ts, 4, 69))
 >a : Symbol(a, Decl(generatorTypeCheck62.ts, 4, 76))
 >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25))
 >a : Symbol(a, Decl(generatorTypeCheck62.ts, 4, 120))
 >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25))
 
     return function*(state) {
@@ -51,7 +51,7 @@ export interface Strategy<T> {
     (a: T): IterableIterator<T | undefined>;
 >a : Symbol(a, Decl(generatorTypeCheck62.ts, 16, 5))
 >T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26))
 }
 
diff --git a/tests/baselines/reference/generatorTypeCheck63.symbols b/tests/baselines/reference/generatorTypeCheck63.symbols
index 4d825e2d056..e142a1b3bb0 100644
--- a/tests/baselines/reference/generatorTypeCheck63.symbols
+++ b/tests/baselines/reference/generatorTypeCheck63.symbols
@@ -14,11 +14,11 @@ export function strategy<T extends StrategicState>(stratName: string, gen: (a: T
 >gen : Symbol(gen, Decl(generatorTypeCheck63.ts, 4, 69))
 >a : Symbol(a, Decl(generatorTypeCheck63.ts, 4, 76))
 >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25))
 >a : Symbol(a, Decl(generatorTypeCheck63.ts, 4, 120))
 >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25))
 
     return function*(state) {
@@ -51,7 +51,7 @@ export interface Strategy<T> {
     (a: T): IterableIterator<T | undefined>;
 >a : Symbol(a, Decl(generatorTypeCheck63.ts, 16, 5))
 >T : Symbol(T, Decl(generatorTypeCheck63.ts, 15, 26))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(generatorTypeCheck63.ts, 15, 26))
 }
 
diff --git a/tests/baselines/reference/generatorTypeCheck7.symbols b/tests/baselines/reference/generatorTypeCheck7.symbols
index 0573de30b7c..d81cbc05c0b 100644
--- a/tests/baselines/reference/generatorTypeCheck7.symbols
+++ b/tests/baselines/reference/generatorTypeCheck7.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts ===
 interface WeirdIter extends IterableIterator<number> {
 >WeirdIter : Symbol(WeirdIter, Decl(generatorTypeCheck7.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es6.d.ts, --, --))
 
     hello: string;
 >hello : Symbol(WeirdIter.hello, Decl(generatorTypeCheck7.ts, 0, 54))
diff --git a/tests/baselines/reference/generatorTypeCheck8.symbols b/tests/baselines/reference/generatorTypeCheck8.symbols
index 2938c6c0dc1..30d067805cd 100644
--- a/tests/baselines/reference/generatorTypeCheck8.symbols
+++ b/tests/baselines/reference/generatorTypeCheck8.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts ===
 interface BadGenerator extends Iterator<number>, Iterable<string> { }
 >BadGenerator : Symbol(BadGenerator, Decl(generatorTypeCheck8.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es6.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
 function* g3(): BadGenerator { }
 >g3 : Symbol(g3, Decl(generatorTypeCheck8.ts, 0, 69))
diff --git a/tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference2.symbols b/tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference2.symbols
index e7e5b7d5b3e..b61cb7746cf 100644
--- a/tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference2.symbols
+++ b/tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference2.symbols
@@ -33,13 +33,13 @@ var r3 = foo(new Object()); // {}
 var r4 = foo<Date, Date>(1); // error
 >r4 : Symbol(r4, Decl(genericCallWithConstraintsTypeArgumentInference2.ts, 10, 3))
 >foo : Symbol(foo, Decl(genericCallWithConstraintsTypeArgumentInference2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r5 = foo<Date, Date>(new Date()); // no error
 >r5 : Symbol(r5, Decl(genericCallWithConstraintsTypeArgumentInference2.ts, 11, 3))
 >foo : Symbol(foo, Decl(genericCallWithConstraintsTypeArgumentInference2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments.symbols b/tests/baselines/reference/genericCallWithGenericSignatureArguments.symbols
index b814c700b8e..5921a53ae5f 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments.symbols
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments.symbols
@@ -109,7 +109,7 @@ function other<T>(x: T) {
 function other2<T extends Date>(x: T) {
 >other2 : Symbol(other2, Decl(genericCallWithGenericSignatureArguments.ts, 23, 1))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments.ts, 25, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericCallWithGenericSignatureArguments.ts, 25, 32))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments.ts, 25, 16))
 
@@ -143,7 +143,7 @@ function other2<T extends Date>(x: T) {
 function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
 >foo2 : Symbol(foo2, Decl(genericCallWithGenericSignatureArguments.ts, 31, 1))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments.ts, 34, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(genericCallWithGenericSignatureArguments.ts, 34, 30))
 >x : Symbol(x, Decl(genericCallWithGenericSignatureArguments.ts, 34, 34))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments.ts, 34, 14))
@@ -174,9 +174,9 @@ function other3<T extends RegExp>(x: T) {
 >r8 : Symbol(r8, Decl(genericCallWithGenericSignatureArguments.ts, 40, 7))
 >foo2 : Symbol(foo2, Decl(genericCallWithGenericSignatureArguments.ts, 31, 1))
 >a : Symbol(a, Decl(genericCallWithGenericSignatureArguments.ts, 40, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(genericCallWithGenericSignatureArguments.ts, 40, 19))
 >b : Symbol(b, Decl(genericCallWithGenericSignatureArguments.ts, 40, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericCallWithGenericSignatureArguments.ts, 40, 35))
 }
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.symbols b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.symbols
index db4bcac853e..8167765041d 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.symbols
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.symbols
@@ -37,7 +37,7 @@ module onlyT {
     function other2<T extends Date>(x: T) {
 >other2 : Symbol(other2, Decl(genericCallWithGenericSignatureArguments2.ts, 9, 69))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 11, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericCallWithGenericSignatureArguments2.ts, 11, 36))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 11, 20))
 
@@ -55,7 +55,7 @@ module onlyT {
         var r9 = r7(new Date()); // should be ok
 >r9 : Symbol(r9, Decl(genericCallWithGenericSignatureArguments2.ts, 14, 11))
 >r7 : Symbol(r7, Decl(genericCallWithGenericSignatureArguments2.ts, 12, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var r10 = r7(1); // error
 >r10 : Symbol(r10, Decl(genericCallWithGenericSignatureArguments2.ts, 15, 11))
@@ -65,7 +65,7 @@ module onlyT {
     function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
 >foo2 : Symbol(foo2, Decl(genericCallWithGenericSignatureArguments2.ts, 16, 5))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 18, 18))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(genericCallWithGenericSignatureArguments2.ts, 18, 34))
 >x : Symbol(x, Decl(genericCallWithGenericSignatureArguments2.ts, 18, 38))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 18, 18))
@@ -195,7 +195,7 @@ module TU {
     function other2<T extends Date>(x: T) {
 >other2 : Symbol(other2, Decl(genericCallWithGenericSignatureArguments2.ts, 45, 69))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 47, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericCallWithGenericSignatureArguments2.ts, 47, 36))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 47, 20))
 
@@ -212,7 +212,7 @@ module TU {
         var r9 = r7(new Date()); 
 >r9 : Symbol(r9, Decl(genericCallWithGenericSignatureArguments2.ts, 49, 11))
 >r7 : Symbol(r7, Decl(genericCallWithGenericSignatureArguments2.ts, 48, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var r10 = r7(1); 
 >r10 : Symbol(r10, Decl(genericCallWithGenericSignatureArguments2.ts, 50, 11))
@@ -222,9 +222,9 @@ module TU {
     function foo2<T extends Date, U extends Date>(a: (x: T) => T, b: (x: U) => U) {
 >foo2 : Symbol(foo2, Decl(genericCallWithGenericSignatureArguments2.ts, 51, 5))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 53, 18))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(genericCallWithGenericSignatureArguments2.ts, 53, 33))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(genericCallWithGenericSignatureArguments2.ts, 53, 50))
 >x : Symbol(x, Decl(genericCallWithGenericSignatureArguments2.ts, 53, 54))
 >T : Symbol(T, Decl(genericCallWithGenericSignatureArguments2.ts, 53, 18))
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols
index 4aa4807b637..2e0c6b86cf6 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols
@@ -20,7 +20,7 @@ var a: {
 
     [x: number]: Date;
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 8, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
 var r = foo(a);
@@ -31,7 +31,7 @@ var r = foo(a);
 function other<T extends Date>(arg: T) {
 >other : Symbol(other, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 10, 15))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 15))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 31))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 15))
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexersErrors.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexersErrors.symbols
index e8371f0cf76..b1465624a09 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexersErrors.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexersErrors.symbols
@@ -40,7 +40,7 @@ function other3<T extends U, U extends Date>(arg: T) {
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexersErrors.ts, 14, 16))
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndIndexersErrors.ts, 14, 28))
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndIndexersErrors.ts, 14, 28))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndIndexersErrors.ts, 14, 45))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexersErrors.ts, 14, 16))
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols
index 58d9d2a3770..6dc56a2c05d 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols
@@ -14,7 +14,7 @@ function foo<T>(x: T) {
 var a: { [x: number]: Date };
 >a : Symbol(a, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 6, 3))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 6, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r = foo(a);
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 7, 3))
@@ -41,7 +41,7 @@ function other<T>(arg: T) {
 function other2<T extends Date>(arg: T) {
 >other2 : Symbol(other2, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 12, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 32))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 16))
 
@@ -63,9 +63,9 @@ function other2<T extends Date>(arg: T) {
 function other3<T extends Date, U extends Date>(arg: T) {
 >other3 : Symbol(other3, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 18, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 31))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 48))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 16))
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols
index 56f1015f620..b680e367dc9 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols
@@ -14,7 +14,7 @@ function foo<T>(x: T) {
 var a: { [x: string]: Date };
 >a : Symbol(a, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 6, 3))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 6, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r = foo(a);
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 7, 3))
@@ -41,7 +41,7 @@ function other<T>(arg: T) {
 function other2<T extends Date>(arg: T) {
 >other2 : Symbol(other2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 12, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 32))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 16))
 
@@ -57,16 +57,16 @@ function other2<T extends Date>(arg: T) {
 
     var d: Date = r2['hm']; // ok
 >d : Symbol(d, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 17, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 16, 7))
 }
 
 function other3<T extends Date, U extends Date>(arg: T) {
 >other3 : Symbol(other3, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 18, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 31))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 48))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 16))
 
@@ -82,7 +82,7 @@ function other3<T extends Date, U extends Date>(arg: T) {
 
     var d: Date = r2['hm']; // ok
 >d : Symbol(d, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 23, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 22, 7))
 
     // BUG 821629
diff --git a/tests/baselines/reference/genericCombinators2.symbols b/tests/baselines/reference/genericCombinators2.symbols
index 63ced3de726..727d9dd2775 100644
--- a/tests/baselines/reference/genericCombinators2.symbols
+++ b/tests/baselines/reference/genericCombinators2.symbols
@@ -81,7 +81,7 @@ var r5a = _.map<number, string, Date>(c2, (x, y) => { return x.toFixed() });
 >_.map : Symbol(Combinators.map, Decl(genericCombinators2.ts, 6, 23), Decl(genericCombinators2.ts, 7, 81))
 >_ : Symbol(_, Decl(genericCombinators2.ts, 11, 3))
 >map : Symbol(Combinators.map, Decl(genericCombinators2.ts, 6, 23), Decl(genericCombinators2.ts, 7, 81))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c2 : Symbol(c2, Decl(genericCombinators2.ts, 12, 3))
 >x : Symbol(x, Decl(genericCombinators2.ts, 14, 43))
 >y : Symbol(y, Decl(genericCombinators2.ts, 14, 45))
@@ -94,7 +94,7 @@ var r5b = _.map<number, string, Date>(c2, rf1);
 >_.map : Symbol(Combinators.map, Decl(genericCombinators2.ts, 6, 23), Decl(genericCombinators2.ts, 7, 81))
 >_ : Symbol(_, Decl(genericCombinators2.ts, 11, 3))
 >map : Symbol(Combinators.map, Decl(genericCombinators2.ts, 6, 23), Decl(genericCombinators2.ts, 7, 81))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c2 : Symbol(c2, Decl(genericCombinators2.ts, 12, 3))
 >rf1 : Symbol(rf1, Decl(genericCombinators2.ts, 13, 3))
 
diff --git a/tests/baselines/reference/genericConstructorFunction1.symbols b/tests/baselines/reference/genericConstructorFunction1.symbols
index f1e0efcc148..a6f177889de 100644
--- a/tests/baselines/reference/genericConstructorFunction1.symbols
+++ b/tests/baselines/reference/genericConstructorFunction1.symbols
@@ -10,7 +10,7 @@ function f1<T>(args: T) {
 >index : Symbol(index, Decl(genericConstructorFunction1.ts, 1, 15))
 >arg : Symbol(arg, Decl(genericConstructorFunction1.ts, 1, 36))
 >T : Symbol(T, Decl(genericConstructorFunction1.ts, 0, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     var v2 = v1['test'];
 >v2 : Symbol(v2, Decl(genericConstructorFunction1.ts, 2, 7))
@@ -31,7 +31,7 @@ interface I1<T> { new (arg: T): Date };
 >T : Symbol(T, Decl(genericConstructorFunction1.ts, 8, 13))
 >arg : Symbol(arg, Decl(genericConstructorFunction1.ts, 8, 23))
 >T : Symbol(T, Decl(genericConstructorFunction1.ts, 8, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function f2<T>(args: T) {
 >f2 : Symbol(f2, Decl(genericConstructorFunction1.ts, 8, 39))
diff --git a/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.errors.txt b/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.errors.txt
index a0c5cbb4378..c8430818983 100644
--- a/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.errors.txt
+++ b/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.errors.txt
@@ -1,9 +1,8 @@
 tests/cases/compiler/genericFunctionCallSignatureReturnTypeMismatch.ts(6,1): error TS2322: Type '<S>() => S[]' is not assignable to type '<T>(x: T) => T'.
   Type '{}[]' is not assignable to type 'T'.
-tests/cases/compiler/genericFunctionCallSignatureReturnTypeMismatch.ts(10,1): error TS2304: Cannot find name 'console'.
 
 
-==== tests/cases/compiler/genericFunctionCallSignatureReturnTypeMismatch.ts (2 errors) ====
+==== tests/cases/compiler/genericFunctionCallSignatureReturnTypeMismatch.ts (1 errors) ====
     interface Array<T> {}
     
     var f : { <T>(x:T): T; }
@@ -17,6 +16,4 @@ tests/cases/compiler/genericFunctionCallSignatureReturnTypeMismatch.ts(10,1): er
     var s = f("str").toUpperCase();
     
     console.log(s);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.symbols b/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.symbols
index 69e5a66b013..15960021263 100644
--- a/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.symbols
+++ b/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.symbols
@@ -26,5 +26,8 @@ var s = f("str").toUpperCase();
 >toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 
 console.log(s);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(genericFunctionCallSignatureReturnTypeMismatch.ts, 7, 3))
 
diff --git a/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.types b/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.types
index 6e999e229ac..3a521adaf7f 100644
--- a/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.types
+++ b/tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.types
@@ -30,9 +30,9 @@ var s = f("str").toUpperCase();
 >toUpperCase : () => string
 
 console.log(s);
->console.log(s) : any
->console.log : any
->console : any
->log : any
+>console.log(s) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >s : string
 
diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
index 398c3a0e71f..7b3184d7bd3 100644
--- a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
+++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
@@ -63,7 +63,7 @@ var r3 = utils.mapReduce(c, (x) => { return 1 }, (y) => { return new Date() });
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 29))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 50))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return new Date() });
 >r4 : Symbol(r4, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 3))
@@ -73,7 +73,7 @@ var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 29))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 58))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f1 = (x: string) => { return 1 };
 >f1 : Symbol(f1, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 3))
@@ -82,7 +82,7 @@ var f1 = (x: string) => { return 1 };
 var f2 = (y: number) => { return new Date() };
 >f2 : Symbol(f2, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 3))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r5 = utils.mapReduce(c, f1, f2);
 >r5 : Symbol(r5, Decl(genericFunctionsWithOptionalParameters3.ts, 13, 3))
diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols
index 9cf7bb995b1..89b0541780c 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.symbols
+++ b/tests/baselines/reference/genericMethodOverspecialization.symbols
@@ -27,9 +27,9 @@ interface Document {
 
 var elements = names.map(function (name) {
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->names.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>names.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35))
 
     return document.getElementById(name);
@@ -43,9 +43,9 @@ var elements = names.map(function (name) {
 
 var xxx = elements.filter(function (e) {
 >xxx : Symbol(xxx, Decl(genericMethodOverspecialization.ts, 17, 3))
->elements.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>elements.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 17, 36))
 
     return !e.isDisabled;
@@ -57,9 +57,9 @@ var xxx = elements.filter(function (e) {
 
 var widths:number[] = elements.map(function (e) { // should not error
 >widths : Symbol(widths, Decl(genericMethodOverspecialization.ts, 21, 3))
->elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>elements.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45))
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/genericPrototypeProperty2.symbols b/tests/baselines/reference/genericPrototypeProperty2.symbols
index 71709239cef..b6957e69840 100644
--- a/tests/baselines/reference/genericPrototypeProperty2.symbols
+++ b/tests/baselines/reference/genericPrototypeProperty2.symbols
@@ -1,6 +1,6 @@
 === tests/cases/compiler/genericPrototypeProperty2.ts ===
 interface EventTarget { x } 
->EventTarget : Symbol(EventTarget, Decl(genericPrototypeProperty2.ts, 0, 0))
+>EventTarget : Symbol(EventTarget, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericPrototypeProperty2.ts, 0, 0))
 >x : Symbol(EventTarget.x, Decl(genericPrototypeProperty2.ts, 0, 23))
 
 class BaseEvent {
@@ -8,13 +8,13 @@ class BaseEvent {
 
     target: EventTarget;
 >target : Symbol(BaseEvent.target, Decl(genericPrototypeProperty2.ts, 1, 17))
->EventTarget : Symbol(EventTarget, Decl(genericPrototypeProperty2.ts, 0, 0))
+>EventTarget : Symbol(EventTarget, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericPrototypeProperty2.ts, 0, 0))
 }
 
 class MyEvent<T extends EventTarget> extends BaseEvent {
 >MyEvent : Symbol(MyEvent, Decl(genericPrototypeProperty2.ts, 3, 1))
 >T : Symbol(T, Decl(genericPrototypeProperty2.ts, 5, 14))
->EventTarget : Symbol(EventTarget, Decl(genericPrototypeProperty2.ts, 0, 0))
+>EventTarget : Symbol(EventTarget, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericPrototypeProperty2.ts, 0, 0))
 >BaseEvent : Symbol(BaseEvent, Decl(genericPrototypeProperty2.ts, 0, 27))
 
     target: T;
diff --git a/tests/baselines/reference/genericSignatureIdentity.symbols b/tests/baselines/reference/genericSignatureIdentity.symbols
index b5caa87b0a5..a5e9d289c3c 100644
--- a/tests/baselines/reference/genericSignatureIdentity.symbols
+++ b/tests/baselines/reference/genericSignatureIdentity.symbols
@@ -9,7 +9,7 @@ var x: {
 
     <T extends Date>(x: T): T;
 >T : Symbol(T, Decl(genericSignatureIdentity.ts, 6, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericSignatureIdentity.ts, 6, 21))
 >T : Symbol(T, Decl(genericSignatureIdentity.ts, 6, 5))
 >T : Symbol(T, Decl(genericSignatureIdentity.ts, 6, 5))
diff --git a/tests/baselines/reference/genericTypeAssertions6.symbols b/tests/baselines/reference/genericTypeAssertions6.symbols
index c7b523b3c53..764988fe42d 100644
--- a/tests/baselines/reference/genericTypeAssertions6.symbols
+++ b/tests/baselines/reference/genericTypeAssertions6.symbols
@@ -40,9 +40,9 @@ class A<T,U> {
 class B<T extends Date, U extends Date> extends A<T, U> {
 >B : Symbol(B, Decl(genericTypeAssertions6.ts, 10, 1))
 >T : Symbol(T, Decl(genericTypeAssertions6.ts, 12, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(genericTypeAssertions6.ts, 12, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(genericTypeAssertions6.ts, 0, 0))
 >T : Symbol(T, Decl(genericTypeAssertions6.ts, 12, 8))
 >U : Symbol(U, Decl(genericTypeAssertions6.ts, 12, 23))
@@ -54,45 +54,45 @@ class B<T extends Date, U extends Date> extends A<T, U> {
 
         var a: Date = x;
 >a : Symbol(a, Decl(genericTypeAssertions6.ts, 14, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericTypeAssertions6.ts, 13, 6))
 
         var b = <Date>x;
 >b : Symbol(b, Decl(genericTypeAssertions6.ts, 15, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericTypeAssertions6.ts, 13, 6))
 
         var c = <T>new Date();
 >c : Symbol(c, Decl(genericTypeAssertions6.ts, 16, 11))
 >T : Symbol(T, Decl(genericTypeAssertions6.ts, 12, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var d = <U>new Date();
 >d : Symbol(d, Decl(genericTypeAssertions6.ts, 17, 11))
 >U : Symbol(U, Decl(genericTypeAssertions6.ts, 12, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var e = <T><U>new Date();
 >e : Symbol(e, Decl(genericTypeAssertions6.ts, 18, 11))
 >T : Symbol(T, Decl(genericTypeAssertions6.ts, 12, 8))
 >U : Symbol(U, Decl(genericTypeAssertions6.ts, 12, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 }
 
 var b: B<Date, Date>;
 >b : Symbol(b, Decl(genericTypeAssertions6.ts, 22, 3))
 >B : Symbol(B, Decl(genericTypeAssertions6.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var c: A<Date, Date> = <A<Date, Date>>b;
 >c : Symbol(c, Decl(genericTypeAssertions6.ts, 23, 3))
 >A : Symbol(A, Decl(genericTypeAssertions6.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(genericTypeAssertions6.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericTypeAssertions6.ts, 22, 3))
 
diff --git a/tests/baselines/reference/importCallExpression4ESNext.js b/tests/baselines/reference/importCallExpression4ESNext.js
index d5d4a51d69f..92298381c3d 100644
--- a/tests/baselines/reference/importCallExpression4ESNext.js
+++ b/tests/baselines/reference/importCallExpression4ESNext.js
@@ -11,7 +11,6 @@ export function foo() { return "foo" }
 export function backup() { return "backup"; }
 
 //// [2.ts]
-declare var console: any;
 class C {
     private myModule = import("./0");
     method() {
diff --git a/tests/baselines/reference/importCallExpression4ESNext.symbols b/tests/baselines/reference/importCallExpression4ESNext.symbols
index ef8d6e9c509..a6dc98b52ed 100644
--- a/tests/baselines/reference/importCallExpression4ESNext.symbols
+++ b/tests/baselines/reference/importCallExpression4ESNext.symbols
@@ -14,52 +14,55 @@ export function backup() { return "backup"; }
 >backup : Symbol(backup, Decl(1.ts, 0, 0))
 
 === tests/cases/conformance/dynamicImport/2.ts ===
-declare var console: any;
->console : Symbol(console, Decl(2.ts, 0, 11))
-
 class C {
->C : Symbol(C, Decl(2.ts, 0, 25))
+>C : Symbol(C, Decl(2.ts, 0, 0))
 
     private myModule = import("./0");
->myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>myModule : Symbol(C.myModule, Decl(2.ts, 0, 9))
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
     method() {
->method : Symbol(C.method, Decl(2.ts, 2, 37))
+>method : Symbol(C.method, Decl(2.ts, 1, 37))
 
         const loadAsync = import ("./0");
->loadAsync : Symbol(loadAsync, Decl(2.ts, 4, 13))
+>loadAsync : Symbol(loadAsync, Decl(2.ts, 3, 13))
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
         this.myModule.then(Zero => {
 >this.myModule.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
->this : Symbol(C, Decl(2.ts, 0, 25))
->myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 0, 9))
+>this : Symbol(C, Decl(2.ts, 0, 0))
+>myModule : Symbol(C.myModule, Decl(2.ts, 0, 9))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Zero : Symbol(Zero, Decl(2.ts, 5, 27))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
 
             console.log(Zero.foo());
->console : Symbol(console, Decl(2.ts, 0, 11))
+>console.log : Symbol(Console.log, Decl(lib.esnext.full.d.ts, --, --))
+>console : Symbol(console, Decl(lib.esnext.full.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.esnext.full.d.ts, --, --))
 >Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
->Zero : Symbol(Zero, Decl(2.ts, 5, 27))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
 >foo : Symbol(foo, Decl(0.ts, 2, 1))
 
         }, async err => {
->err : Symbol(err, Decl(2.ts, 7, 16))
+>err : Symbol(err, Decl(2.ts, 6, 16))
 
             console.log(err);
->console : Symbol(console, Decl(2.ts, 0, 11))
->err : Symbol(err, Decl(2.ts, 7, 16))
+>console.log : Symbol(Console.log, Decl(lib.esnext.full.d.ts, --, --))
+>console : Symbol(console, Decl(lib.esnext.full.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.esnext.full.d.ts, --, --))
+>err : Symbol(err, Decl(2.ts, 6, 16))
 
             let one = await import("./1");
->one : Symbol(one, Decl(2.ts, 9, 15))
+>one : Symbol(one, Decl(2.ts, 8, 15))
 >"./1" : Symbol("tests/cases/conformance/dynamicImport/1", Decl(1.ts, 0, 0))
 
             console.log(one.backup());
->console : Symbol(console, Decl(2.ts, 0, 11))
+>console.log : Symbol(Console.log, Decl(lib.esnext.full.d.ts, --, --))
+>console : Symbol(console, Decl(lib.esnext.full.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.esnext.full.d.ts, --, --))
 >one.backup : Symbol(backup, Decl(1.ts, 0, 0))
->one : Symbol(one, Decl(2.ts, 9, 15))
+>one : Symbol(one, Decl(2.ts, 8, 15))
 >backup : Symbol(backup, Decl(1.ts, 0, 0))
 
         });
diff --git a/tests/baselines/reference/importCallExpression4ESNext.types b/tests/baselines/reference/importCallExpression4ESNext.types
index 74cc6ff8b28..00d6ce707d3 100644
--- a/tests/baselines/reference/importCallExpression4ESNext.types
+++ b/tests/baselines/reference/importCallExpression4ESNext.types
@@ -17,9 +17,6 @@ export function backup() { return "backup"; }
 >"backup" : "backup"
 
 === tests/cases/conformance/dynamicImport/2.ts ===
-declare var console: any;
->console : any
-
 class C {
 >C : C
 
@@ -47,10 +44,10 @@ class C {
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
             console.log(Zero.foo());
->console.log(Zero.foo()) : any
->console.log : any
->console : any
->log : any
+>console.log(Zero.foo()) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >Zero.foo() : string
 >Zero.foo : () => string
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
@@ -61,10 +58,10 @@ class C {
 >err : any
 
             console.log(err);
->console.log(err) : any
->console.log : any
->console : any
->log : any
+>console.log(err) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >err : any
 
             let one = await import("./1");
@@ -74,10 +71,10 @@ class C {
 >"./1" : "./1"
 
             console.log(one.backup());
->console.log(one.backup()) : any
->console.log : any
->console : any
->log : any
+>console.log(one.backup()) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >one.backup() : string
 >one.backup : () => string
 >one : typeof "tests/cases/conformance/dynamicImport/1"
diff --git a/tests/baselines/reference/importCallExpressionCheckReturntype1.symbols b/tests/baselines/reference/importCallExpressionCheckReturntype1.symbols
index 566f1aa5ca1..4a271e6bd49 100644
--- a/tests/baselines/reference/importCallExpressionCheckReturntype1.symbols
+++ b/tests/baselines/reference/importCallExpressionCheckReturntype1.symbols
@@ -15,18 +15,18 @@ import * as anotherModule from "./anotherModule";
 
 let p1: Promise<typeof anotherModule> = import("./defaultPath");
 >p1 : Symbol(p1, Decl(1.ts, 3, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >anotherModule : Symbol(anotherModule, Decl(1.ts, 1, 6))
 >"./defaultPath" : Symbol(defaultModule, Decl(defaultPath.ts, 0, 0))
 
 let p2 = import("./defaultPath") as Promise<typeof anotherModule>;
 >p2 : Symbol(p2, Decl(1.ts, 4, 3))
 >"./defaultPath" : Symbol(defaultModule, Decl(defaultPath.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >anotherModule : Symbol(anotherModule, Decl(1.ts, 1, 6))
 
 let p3: Promise<any> = import("./defaultPath");
 >p3 : Symbol(p3, Decl(1.ts, 5, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >"./defaultPath" : Symbol(defaultModule, Decl(defaultPath.ts, 0, 0))
 
diff --git a/tests/baselines/reference/importCallExpressionES6AMD.symbols b/tests/baselines/reference/importCallExpressionES6AMD.symbols
index 2f8bd23758d..bac881bbcb9 100644
--- a/tests/baselines/reference/importCallExpressionES6AMD.symbols
+++ b/tests/baselines/reference/importCallExpressionES6AMD.symbols
@@ -11,9 +11,9 @@ var p1 = import("./0");
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
 p1.then(zero => {
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p1 : Symbol(p1, Decl(1.ts, 1, 3))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >zero : Symbol(zero, Decl(1.ts, 2, 8))
 
     return zero.foo();
diff --git a/tests/baselines/reference/importCallExpressionES6CJS.symbols b/tests/baselines/reference/importCallExpressionES6CJS.symbols
index 2f8bd23758d..bac881bbcb9 100644
--- a/tests/baselines/reference/importCallExpressionES6CJS.symbols
+++ b/tests/baselines/reference/importCallExpressionES6CJS.symbols
@@ -11,9 +11,9 @@ var p1 = import("./0");
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
 p1.then(zero => {
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p1 : Symbol(p1, Decl(1.ts, 1, 3))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >zero : Symbol(zero, Decl(1.ts, 2, 8))
 
     return zero.foo();
diff --git a/tests/baselines/reference/importCallExpressionES6System.symbols b/tests/baselines/reference/importCallExpressionES6System.symbols
index 2f8bd23758d..bac881bbcb9 100644
--- a/tests/baselines/reference/importCallExpressionES6System.symbols
+++ b/tests/baselines/reference/importCallExpressionES6System.symbols
@@ -11,9 +11,9 @@ var p1 = import("./0");
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
 p1.then(zero => {
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p1 : Symbol(p1, Decl(1.ts, 1, 3))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >zero : Symbol(zero, Decl(1.ts, 2, 8))
 
     return zero.foo();
diff --git a/tests/baselines/reference/importCallExpressionES6UMD.symbols b/tests/baselines/reference/importCallExpressionES6UMD.symbols
index 2f8bd23758d..bac881bbcb9 100644
--- a/tests/baselines/reference/importCallExpressionES6UMD.symbols
+++ b/tests/baselines/reference/importCallExpressionES6UMD.symbols
@@ -11,9 +11,9 @@ var p1 = import("./0");
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
 p1.then(zero => {
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p1 : Symbol(p1, Decl(1.ts, 1, 3))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >zero : Symbol(zero, Decl(1.ts, 2, 8))
 
     return zero.foo();
diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.errors.txt b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.errors.txt
index b422869ff21..4e8496ce742 100644
--- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.errors.txt
+++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.errors.txt
@@ -1,8 +1,8 @@
 error TS2468: Cannot find global value 'Promise'.
-tests/cases/conformance/dynamicImport/2.ts(3,24): error TS2712: A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
-tests/cases/conformance/dynamicImport/2.ts(5,27): error TS2712: A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
-tests/cases/conformance/dynamicImport/2.ts(8,12): error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
-tests/cases/conformance/dynamicImport/2.ts(10,29): error TS2712: A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
+tests/cases/conformance/dynamicImport/2.ts(2,24): error TS2712: A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
+tests/cases/conformance/dynamicImport/2.ts(4,27): error TS2712: A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
+tests/cases/conformance/dynamicImport/2.ts(7,12): error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
+tests/cases/conformance/dynamicImport/2.ts(9,29): error TS2712: A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
 
 
 !!! error TS2468: Cannot find global value 'Promise'.
@@ -17,7 +17,6 @@ tests/cases/conformance/dynamicImport/2.ts(10,29): error TS2712: A dynamic impor
     export function backup() { return "backup"; }
     
 ==== tests/cases/conformance/dynamicImport/2.ts (4 errors) ====
-    declare var console: any;
     class C {
         private myModule = import("./0");
                            ~~~~~~~~~~~~~
diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.js b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.js
index 3135a4066fd..65f69fea4ca 100644
--- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.js
+++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.js
@@ -11,7 +11,6 @@ export function foo() { return "foo" }
 export function backup() { return "backup"; }
 
 //// [2.ts]
-declare var console: any;
 class C {
     private myModule = import("./0");
     method() {
diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.symbols b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.symbols
index a30acb72d2c..fb5a12e2e22 100644
--- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.symbols
+++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.symbols
@@ -14,52 +14,55 @@ export function backup() { return "backup"; }
 >backup : Symbol(backup, Decl(1.ts, 0, 0))
 
 === tests/cases/conformance/dynamicImport/2.ts ===
-declare var console: any;
->console : Symbol(console, Decl(2.ts, 0, 11))
-
 class C {
->C : Symbol(C, Decl(2.ts, 0, 25))
+>C : Symbol(C, Decl(2.ts, 0, 0))
 
     private myModule = import("./0");
->myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>myModule : Symbol(C.myModule, Decl(2.ts, 0, 9))
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
     method() {
->method : Symbol(C.method, Decl(2.ts, 2, 37))
+>method : Symbol(C.method, Decl(2.ts, 1, 37))
 
         const loadAsync = import("./0");
->loadAsync : Symbol(loadAsync, Decl(2.ts, 4, 13))
+>loadAsync : Symbol(loadAsync, Decl(2.ts, 3, 13))
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
         this.myModule.then(Zero => {
 >this.myModule.then : Symbol(Promise.then, Decl(lib.d.ts, --, --))
->this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
->this : Symbol(C, Decl(2.ts, 0, 25))
->myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 0, 9))
+>this : Symbol(C, Decl(2.ts, 0, 0))
+>myModule : Symbol(C.myModule, Decl(2.ts, 0, 9))
 >then : Symbol(Promise.then, Decl(lib.d.ts, --, --))
->Zero : Symbol(Zero, Decl(2.ts, 5, 27))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
 
             console.log(Zero.foo());
->console : Symbol(console, Decl(2.ts, 0, 11))
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
->Zero : Symbol(Zero, Decl(2.ts, 5, 27))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
 >foo : Symbol(foo, Decl(0.ts, 2, 1))
 
         }, async err => {
->err : Symbol(err, Decl(2.ts, 7, 16))
+>err : Symbol(err, Decl(2.ts, 6, 16))
 
             console.log(err);
->console : Symbol(console, Decl(2.ts, 0, 11))
->err : Symbol(err, Decl(2.ts, 7, 16))
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>err : Symbol(err, Decl(2.ts, 6, 16))
 
             let one = await import("./1");
->one : Symbol(one, Decl(2.ts, 9, 15))
+>one : Symbol(one, Decl(2.ts, 8, 15))
 >"./1" : Symbol("tests/cases/conformance/dynamicImport/1", Decl(1.ts, 0, 0))
 
             console.log(one.backup());
->console : Symbol(console, Decl(2.ts, 0, 11))
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >one.backup : Symbol(backup, Decl(1.ts, 0, 0))
->one : Symbol(one, Decl(2.ts, 9, 15))
+>one : Symbol(one, Decl(2.ts, 8, 15))
 >backup : Symbol(backup, Decl(1.ts, 0, 0))
 
         });
diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
index 552e3cf9206..bf0a421cd0f 100644
--- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
+++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
@@ -17,9 +17,6 @@ export function backup() { return "backup"; }
 >"backup" : "backup"
 
 === tests/cases/conformance/dynamicImport/2.ts ===
-declare var console: any;
->console : any
-
 class C {
 >C : C
 
@@ -47,10 +44,10 @@ class C {
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
             console.log(Zero.foo());
->console.log(Zero.foo()) : any
->console.log : any
->console : any
->log : any
+>console.log(Zero.foo()) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >Zero.foo() : string
 >Zero.foo : () => string
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
@@ -61,10 +58,10 @@ class C {
 >err : any
 
             console.log(err);
->console.log(err) : any
->console.log : any
->console : any
->log : any
+>console.log(err) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >err : any
 
             let one = await import("./1");
@@ -74,10 +71,10 @@ class C {
 >"./1" : "./1"
 
             console.log(one.backup());
->console.log(one.backup()) : any
->console.log : any
->console : any
->log : any
+>console.log(one.backup()) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >one.backup() : string
 >one.backup : () => string
 >one : typeof "tests/cases/conformance/dynamicImport/1"
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols
index 3cb4d99ad25..69a657da40d 100644
--- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols
@@ -33,12 +33,12 @@ var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
 
 var p1: Promise<any> = import(getSpecifier());
 >p1 : Symbol(p1, Decl(1.ts, 10, 3), Decl(1.ts, 11, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
 
 var p11: Promise<typeof defaultModule> = import(getSpecifier());
 >p11 : Symbol(p11, Decl(1.ts, 12, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
 >getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
 
@@ -46,13 +46,13 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof
 >p2 : Symbol(p2, Decl(1.ts, 13, 5))
 >whatToLoad : Symbol(whatToLoad, Decl(1.ts, 3, 11))
 >getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
 
 p1.then(zero => {
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p1 : Symbol(p1, Decl(1.ts, 10, 3), Decl(1.ts, 11, 3))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >zero : Symbol(zero, Decl(1.ts, 14, 8))
 
     return zero.foo();  // ok, zero is any
@@ -65,7 +65,7 @@ let j: string;
 
 var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
 >p3 : Symbol(p3, Decl(1.ts, 19, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
 >j : Symbol(j, Decl(1.ts, 18, 3))
 >getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
diff --git a/tests/baselines/reference/importCallExpressionShouldNotGetParen.symbols b/tests/baselines/reference/importCallExpressionShouldNotGetParen.symbols
index ace34efcf0d..7e83ad1b125 100644
--- a/tests/baselines/reference/importCallExpressionShouldNotGetParen.symbols
+++ b/tests/baselines/reference/importCallExpressionShouldNotGetParen.symbols
@@ -3,9 +3,9 @@ const localeName = "zh-CN";
 >localeName : Symbol(localeName, Decl(importCallExpressionShouldNotGetParen.ts, 0, 5))
 
 import(`./locales/${localeName}.js`).then(bar => {
->import(`./locales/${localeName}.js`).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>import(`./locales/${localeName}.js`).then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >localeName : Symbol(localeName, Decl(importCallExpressionShouldNotGetParen.ts, 0, 5))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >bar : Symbol(bar, Decl(importCallExpressionShouldNotGetParen.ts, 1, 42))
 
     let x = bar;
@@ -15,9 +15,9 @@ import(`./locales/${localeName}.js`).then(bar => {
 });
 
 import("./locales/" + localeName + ".js").then(bar => {
->import("./locales/" + localeName + ".js").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>import("./locales/" + localeName + ".js").then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >localeName : Symbol(localeName, Decl(importCallExpressionShouldNotGetParen.ts, 0, 5))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >bar : Symbol(bar, Decl(importCallExpressionShouldNotGetParen.ts, 5, 47))
 
     let x = bar;
diff --git a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.symbols b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.symbols
index adfbd7705ff..fbf0705d982 100644
--- a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.symbols
+++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.symbols
@@ -19,9 +19,9 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
 >getSpecifier : Symbol(getSpecifier, Decl(importCallExpressionSpecifierNotStringTypeError.ts, 0, 0))
 
 p1.then(zero => {
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p1 : Symbol(p1, Decl(importCallExpressionSpecifierNotStringTypeError.ts, 5, 3))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >zero : Symbol(zero, Decl(importCallExpressionSpecifierNotStringTypeError.ts, 7, 8))
 
     return zero.foo();  // ok, zero is any
diff --git a/tests/baselines/reference/importCallExpressionWithTypeArgument.symbols b/tests/baselines/reference/importCallExpressionWithTypeArgument.symbols
index e8db2d6a7d4..48b082da4fb 100644
--- a/tests/baselines/reference/importCallExpressionWithTypeArgument.symbols
+++ b/tests/baselines/reference/importCallExpressionWithTypeArgument.symbols
@@ -6,7 +6,7 @@ export function foo() { return "foo"; }
 "use strict"
 var p1 = import<Promise<any>>("./0");  // error
 >p1 : Symbol(p1, Decl(1.ts, 1, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >"./0" : Symbol("tests/cases/conformance/dynamicImport/0", Decl(0.ts, 0, 0))
 
 var p2 = import<>("./0");  // error
diff --git a/tests/baselines/reference/importHelpersES6.symbols b/tests/baselines/reference/importHelpersES6.symbols
index 66a8b131aec..ef1193275ad 100644
--- a/tests/baselines/reference/importHelpersES6.symbols
+++ b/tests/baselines/reference/importHelpersES6.symbols
@@ -20,14 +20,14 @@ const y = { ...o };
 export declare function __extends(d: Function, b: Function): void;
 >__extends : Symbol(__extends, Decl(tslib.d.ts, --, --))
 >d : Symbol(d, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >b : Symbol(b, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
 >__decorate : Symbol(__decorate, Decl(tslib.d.ts, --, --))
 >decorators : Symbol(decorators, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >target : Symbol(target, Decl(tslib.d.ts, --, --))
 >key : Symbol(key, Decl(tslib.d.ts, --, --))
 >desc : Symbol(desc, Decl(tslib.d.ts, --, --))
@@ -36,21 +36,21 @@ export declare function __param(paramIndex: number, decorator: Function): Functi
 >__param : Symbol(__param, Decl(tslib.d.ts, --, --))
 >paramIndex : Symbol(paramIndex, Decl(tslib.d.ts, --, --))
 >decorator : Symbol(decorator, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 export declare function __metadata(metadataKey: any, metadataValue: any): Function;
 >__metadata : Symbol(__metadata, Decl(tslib.d.ts, --, --))
 >metadataKey : Symbol(metadataKey, Decl(tslib.d.ts, --, --))
 >metadataValue : Symbol(metadataValue, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 export declare function __awaiter(thisArg: any, _arguments: any, P: Function, generator: Function): any;
 >__awaiter : Symbol(__awaiter, Decl(tslib.d.ts, --, --))
 >thisArg : Symbol(thisArg, Decl(tslib.d.ts, --, --))
 >_arguments : Symbol(_arguments, Decl(tslib.d.ts, --, --))
 >P : Symbol(P, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >generator : Symbol(generator, Decl(tslib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/incompatibleExports1.symbols b/tests/baselines/reference/incompatibleExports1.symbols
index bc69907d298..56068d6019b 100644
--- a/tests/baselines/reference/incompatibleExports1.symbols
+++ b/tests/baselines/reference/incompatibleExports1.symbols
@@ -7,7 +7,7 @@ declare module "foo" {
     interface y { a: Date }
 >y : Symbol(y, Decl(incompatibleExports1.ts, 1, 36))
 >a : Symbol(y.a, Decl(incompatibleExports1.ts, 2, 17))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     export = y;
 >y : Symbol(y, Decl(incompatibleExports1.ts, 1, 36))
diff --git a/tests/baselines/reference/incompatibleExports2.symbols b/tests/baselines/reference/incompatibleExports2.symbols
index bedba8db191..c7d84cffd0e 100644
--- a/tests/baselines/reference/incompatibleExports2.symbols
+++ b/tests/baselines/reference/incompatibleExports2.symbols
@@ -7,7 +7,7 @@ declare module "foo" {
     interface y { a: Date }
 >y : Symbol(y, Decl(incompatibleExports2.ts, 1, 36))
 >a : Symbol(y.a, Decl(incompatibleExports2.ts, 2, 17))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     export = y;
 >y : Symbol(y, Decl(incompatibleExports2.ts, 1, 36))
diff --git a/tests/baselines/reference/incompleteDottedExpressionAtEOF.errors.txt b/tests/baselines/reference/incompleteDottedExpressionAtEOF.errors.txt
index 02348777190..980cf3790ea 100644
--- a/tests/baselines/reference/incompleteDottedExpressionAtEOF.errors.txt
+++ b/tests/baselines/reference/incompleteDottedExpressionAtEOF.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/compiler/incompleteDottedExpressionAtEOF.ts(2,10): error TS2304: Cannot find name 'window'.
 tests/cases/compiler/incompleteDottedExpressionAtEOF.ts(2,17): error TS1003: Identifier expected.
 
 
-==== tests/cases/compiler/incompleteDottedExpressionAtEOF.ts (2 errors) ====
+==== tests/cases/compiler/incompleteDottedExpressionAtEOF.ts (1 errors) ====
     // used to leak __missing into error message
     var p2 = window. 
-             ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
                     
 !!! error TS1003: Identifier expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/incompleteDottedExpressionAtEOF.symbols b/tests/baselines/reference/incompleteDottedExpressionAtEOF.symbols
index c75ce38039f..cb00bda7ec4 100644
--- a/tests/baselines/reference/incompleteDottedExpressionAtEOF.symbols
+++ b/tests/baselines/reference/incompleteDottedExpressionAtEOF.symbols
@@ -2,4 +2,5 @@
 // used to leak __missing into error message
 var p2 = window. 
 >p2 : Symbol(p2, Decl(incompleteDottedExpressionAtEOF.ts, 1, 3))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/incompleteDottedExpressionAtEOF.types b/tests/baselines/reference/incompleteDottedExpressionAtEOF.types
index d20074c0e35..c5daa21498d 100644
--- a/tests/baselines/reference/incompleteDottedExpressionAtEOF.types
+++ b/tests/baselines/reference/incompleteDottedExpressionAtEOF.types
@@ -3,6 +3,6 @@
 var p2 = window. 
 >p2 : any
 >window. : any
->window : any
+>window : Window
 > : any
 
diff --git a/tests/baselines/reference/incrementAndDecrement.errors.txt b/tests/baselines/reference/incrementAndDecrement.errors.txt
index d41764176a4..76e96d7187b 100644
--- a/tests/baselines/reference/incrementAndDecrement.errors.txt
+++ b/tests/baselines/reference/incrementAndDecrement.errors.txt
@@ -1,4 +1,3 @@
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(5,9): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(8,5): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(11,5): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(14,5): error TS1005: ';' expected.
@@ -27,24 +26,30 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(46,4): er
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(46,6): error TS1109: Expression expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(47,4): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(47,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(51,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(52,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(53,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(54,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(55,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(55,4): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(55,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(56,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(56,4): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(56,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(57,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(57,4): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(57,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,4): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,6): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/operators/incrementAndDecrement.ts (37 errors) ====
+==== tests/cases/conformance/expressions/operators/incrementAndDecrement.ts (44 errors) ====
     enum E { A, B, C };
     var x = 4;
     var e = E.B;
     var a: any;
     var w = window;
-            ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     
     // Assign to expression++
     x++ = 4; // Error
@@ -147,25 +152,41 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,6): er
     
     // Pre and postfix++ on other types
     w++; // Error
+    ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     w--; // Error
+    ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     ++w; // Error
+      ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     --w; // Error
+      ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     ++w++; // Error
+      ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
        ~~
 !!! error TS1005: ';' expected.
          ~
 !!! error TS1109: Expression expected.
     --w--; // Error
+      ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
        ~~
 !!! error TS1005: ';' expected.
          ~
 !!! error TS1109: Expression expected.
     ++w--; // Error
+      ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
        ~~
 !!! error TS1005: ';' expected.
          ~
 !!! error TS1109: Expression expected.
     --w++; // Error
+      ~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
        ~~
 !!! error TS1005: ';' expected.
          ~
diff --git a/tests/baselines/reference/incrementAndDecrement.symbols b/tests/baselines/reference/incrementAndDecrement.symbols
index 45a0a19fcba..2990997d641 100644
--- a/tests/baselines/reference/incrementAndDecrement.symbols
+++ b/tests/baselines/reference/incrementAndDecrement.symbols
@@ -19,6 +19,7 @@ var a: any;
 
 var w = window;
 >w : Symbol(w, Decl(incrementAndDecrement.ts, 4, 3))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 
 // Assign to expression++
 x++ = 4; // Error
diff --git a/tests/baselines/reference/incrementAndDecrement.types b/tests/baselines/reference/incrementAndDecrement.types
index 582ed58bc3c..3ec3e36c3f3 100644
--- a/tests/baselines/reference/incrementAndDecrement.types
+++ b/tests/baselines/reference/incrementAndDecrement.types
@@ -19,8 +19,8 @@ var a: any;
 >a : any
 
 var w = window;
->w : any
->window : any
+>w : Window
+>window : Window
 
 // Assign to expression++
 x++ = 4; // Error
@@ -173,41 +173,41 @@ a--;
 // Pre and postfix++ on other types
 w++; // Error
 >w++ : number
->w : any
+>w : Window
 
 w--; // Error
 >w-- : number
->w : any
+>w : Window
 
 ++w; // Error
 >++w : number
->w : any
+>w : Window
 
 --w; // Error
 >--w : number
->w : any
+>w : Window
 
 ++w++; // Error
 >++w : number
->w : any
+>w : Window
 >++ : number
 > : any
 
 --w--; // Error
 >--w : number
->w : any
+>w : Window
 >-- : number
 > : any
 
 ++w--; // Error
 >++w : number
->w : any
+>w : Window
 >-- : number
 > : any
 
 --w++; // Error
 >--w : number
->w : any
+>w : Window
 >++ : number
 > : any
 
diff --git a/tests/baselines/reference/indexer3.symbols b/tests/baselines/reference/indexer3.symbols
index 03b055b343f..071a160b067 100644
--- a/tests/baselines/reference/indexer3.symbols
+++ b/tests/baselines/reference/indexer3.symbols
@@ -2,10 +2,10 @@
 var dateMap: { [x: string]: Date; } = {}
 >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3))
 >x : Symbol(x, Decl(indexer3.ts, 0, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r: Date = dateMap["hello"] // result type includes indexer using BCT
 >r : Symbol(r, Decl(indexer3.ts, 1, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3))
 
diff --git a/tests/baselines/reference/indexersInClassType.symbols b/tests/baselines/reference/indexersInClassType.symbols
index c57c7cf7522..8e0d382dde7 100644
--- a/tests/baselines/reference/indexersInClassType.symbols
+++ b/tests/baselines/reference/indexersInClassType.symbols
@@ -4,14 +4,14 @@ class C {
 
     [x: number]: Date;
 >x : Symbol(x, Decl(indexersInClassType.ts, 1, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: string]: Object;
 >x : Symbol(x, Decl(indexersInClassType.ts, 2, 5))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     1: Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     'a': {}
 
diff --git a/tests/baselines/reference/inferenceLimit.symbols b/tests/baselines/reference/inferenceLimit.symbols
index 1ae8ca5f1df..c11227b29bb 100644
--- a/tests/baselines/reference/inferenceLimit.symbols
+++ b/tests/baselines/reference/inferenceLimit.symbols
@@ -14,8 +14,8 @@ export class BrokenClass {
 >value : Symbol(value, Decl(file1.ts, 7, 36))
 
   return new Promise<Array<MyModule.MyModel>>((resolve, reject) => {
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >MyModule : Symbol(MyModule, Decl(file1.ts, 1, 6))
 >MyModel : Symbol(MyModule.MyModel, Decl(mymodule.ts, 0, 0))
 >resolve : Symbol(resolve, Decl(file1.ts, 8, 47))
@@ -23,7 +23,7 @@ export class BrokenClass {
 
     let result: Array<MyModule.MyModel> = [];
 >result : Symbol(result, Decl(file1.ts, 10, 7))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >MyModule : Symbol(MyModule, Decl(file1.ts, 1, 6))
 >MyModel : Symbol(MyModule.MyModel, Decl(mymodule.ts, 0, 0))
 
@@ -32,19 +32,19 @@ export class BrokenClass {
 >order : Symbol(order, Decl(file1.ts, 12, 25))
 
       return new Promise((resolve, reject) => {
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(file1.ts, 13, 26))
 >reject : Symbol(reject, Decl(file1.ts, 13, 34))
 
         this.doStuff(order.id)
->this.doStuff(order.id)          .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>this.doStuff(order.id)          .then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >this.doStuff : Symbol(BrokenClass.doStuff, Decl(file1.ts, 27, 3))
 >this : Symbol(BrokenClass, Decl(file1.ts, 1, 39))
 >doStuff : Symbol(BrokenClass.doStuff, Decl(file1.ts, 27, 3))
 >order : Symbol(order, Decl(file1.ts, 12, 25))
 
           .then((items) => {
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >items : Symbol(items, Decl(file1.ts, 15, 17))
 
             order.items = items;
@@ -60,19 +60,19 @@ export class BrokenClass {
     };
 
     return Promise.all(result.map(populateItems))
->Promise.all(result.map(populateItems))      .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
->result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>Promise.all(result.map(populateItems))      .then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 6 more)
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>all : Symbol(PromiseConstructor.all, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 6 more)
+>result.map : Symbol(Array.map, Decl(lib.es6.d.ts, --, --))
 >result : Symbol(result, Decl(file1.ts, 10, 7))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es6.d.ts, --, --))
 >populateItems : Symbol(populateItems, Decl(file1.ts, 12, 7))
 
       .then((orders: Array<MyModule.MyModel>) => {
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >orders : Symbol(orders, Decl(file1.ts, 23, 13))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >MyModule : Symbol(MyModule, Decl(file1.ts, 1, 6))
 >MyModel : Symbol(MyModule.MyModel, Decl(mymodule.ts, 0, 0))
 
diff --git a/tests/baselines/reference/infinitelyExpandingTypes2.errors.txt b/tests/baselines/reference/infinitelyExpandingTypes2.errors.txt
deleted file mode 100644
index 3f79b63ca1e..00000000000
--- a/tests/baselines/reference/infinitelyExpandingTypes2.errors.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-tests/cases/compiler/infinitelyExpandingTypes2.ts(10,5): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/infinitelyExpandingTypes2.ts (1 errors) ====
-    interface Foo<T> {
-        x: Foo<Foo<T>>;
-    } 
-    
-    interface Bar<T> extends Foo<T> {
-        y: string;
-    }
-    
-    function f(p: Foo<number>) {
-        console.log(p);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    }
-    
-    var v: Bar<number> = null;
-    
-    f(v); // should not error
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/infinitelyExpandingTypes2.symbols b/tests/baselines/reference/infinitelyExpandingTypes2.symbols
index 7f7554fb5fc..02fbf72221d 100644
--- a/tests/baselines/reference/infinitelyExpandingTypes2.symbols
+++ b/tests/baselines/reference/infinitelyExpandingTypes2.symbols
@@ -26,6 +26,9 @@ function f(p: Foo<number>) {
 >Foo : Symbol(Foo, Decl(infinitelyExpandingTypes2.ts, 0, 0))
 
     console.log(p);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(infinitelyExpandingTypes2.ts, 8, 11))
 }
 
diff --git a/tests/baselines/reference/infinitelyExpandingTypes2.types b/tests/baselines/reference/infinitelyExpandingTypes2.types
index 9dd5652c652..cac10242988 100644
--- a/tests/baselines/reference/infinitelyExpandingTypes2.types
+++ b/tests/baselines/reference/infinitelyExpandingTypes2.types
@@ -26,10 +26,10 @@ function f(p: Foo<number>) {
 >Foo : Foo<T>
 
     console.log(p);
->console.log(p) : any
->console.log : any
->console : any
->log : any
+>console.log(p) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >p : Foo<number>
 }
 
diff --git a/tests/baselines/reference/infinitelyExpandingTypes5.symbols b/tests/baselines/reference/infinitelyExpandingTypes5.symbols
index 32283da9c5d..b990fad0245 100644
--- a/tests/baselines/reference/infinitelyExpandingTypes5.symbols
+++ b/tests/baselines/reference/infinitelyExpandingTypes5.symbols
@@ -12,13 +12,13 @@ interface Query<T> {
 }
 
 interface Enumerator<T> {
->Enumerator : Symbol(Enumerator, Decl(infinitelyExpandingTypes5.ts, 2, 1))
->T : Symbol(T, Decl(infinitelyExpandingTypes5.ts, 4, 21))
+>Enumerator : Symbol(Enumerator, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(infinitelyExpandingTypes5.ts, 2, 1))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(infinitelyExpandingTypes5.ts, 4, 21))
 
     (action: (item: T, index: number) => boolean): boolean;
 >action : Symbol(action, Decl(infinitelyExpandingTypes5.ts, 5, 5))
 >item : Symbol(item, Decl(infinitelyExpandingTypes5.ts, 5, 14))
->T : Symbol(T, Decl(infinitelyExpandingTypes5.ts, 4, 21))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(infinitelyExpandingTypes5.ts, 4, 21))
 >index : Symbol(index, Decl(infinitelyExpandingTypes5.ts, 5, 22))
 }
 
@@ -34,7 +34,7 @@ function from<T>(enumerator: Enumerator<T>): Query<T>;
 >from : Symbol(from, Decl(infinitelyExpandingTypes5.ts, 6, 1), Decl(infinitelyExpandingTypes5.ts, 8, 39), Decl(infinitelyExpandingTypes5.ts, 9, 54))
 >T : Symbol(T, Decl(infinitelyExpandingTypes5.ts, 9, 14))
 >enumerator : Symbol(enumerator, Decl(infinitelyExpandingTypes5.ts, 9, 17))
->Enumerator : Symbol(Enumerator, Decl(infinitelyExpandingTypes5.ts, 2, 1))
+>Enumerator : Symbol(Enumerator, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(infinitelyExpandingTypes5.ts, 2, 1))
 >T : Symbol(T, Decl(infinitelyExpandingTypes5.ts, 9, 14))
 >Query : Symbol(Query, Decl(infinitelyExpandingTypes5.ts, 0, 0))
 >T : Symbol(T, Decl(infinitelyExpandingTypes5.ts, 9, 14))
diff --git a/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols b/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols
index dad2ac6f886..0e83ce75be9 100644
--- a/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols
+++ b/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols
@@ -12,7 +12,7 @@ class B<T> extends A<T> {}
 var a = new A<Date>();
 >a : Symbol(a, Decl(inheritanceOfGenericConstructorMethod1.ts, 2, 3))
 >A : Symbol(A, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b1 = new B(); // no error
 >b1 : Symbol(b1, Decl(inheritanceOfGenericConstructorMethod1.ts, 3, 3))
@@ -21,12 +21,12 @@ var b1 = new B(); // no error
 var b2: B<Date> = new B<Date>(); // no error
 >b2 : Symbol(b2, Decl(inheritanceOfGenericConstructorMethod1.ts, 4, 3))
 >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b3 = new B<Date>(); // error, could not select overload for 'new' expression
 >b3 : Symbol(b3, Decl(inheritanceOfGenericConstructorMethod1.ts, 5, 3))
 >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/inheritedGenericCallSignature.symbols b/tests/baselines/reference/inheritedGenericCallSignature.symbols
index 715393e6a31..63e2c45cd06 100644
--- a/tests/baselines/reference/inheritedGenericCallSignature.symbols
+++ b/tests/baselines/reference/inheritedGenericCallSignature.symbols
@@ -33,7 +33,7 @@ interface I2<T> extends I1<T[]> {
 var x: I2<Date>;
 >x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 19, 3))
 >I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 7, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
  
 
diff --git a/tests/baselines/reference/inlineSourceMap.errors.txt b/tests/baselines/reference/inlineSourceMap.errors.txt
deleted file mode 100644
index 69ea738f6bd..00000000000
--- a/tests/baselines/reference/inlineSourceMap.errors.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-tests/cases/compiler/inlineSourceMap.ts(2,1): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/inlineSourceMap.ts (1 errors) ====
-    var x = 0;
-    console.log(x);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
\ No newline at end of file
diff --git a/tests/baselines/reference/inlineSourceMap.symbols b/tests/baselines/reference/inlineSourceMap.symbols
index 63f8111fea5..5b47c580181 100644
--- a/tests/baselines/reference/inlineSourceMap.symbols
+++ b/tests/baselines/reference/inlineSourceMap.symbols
@@ -3,5 +3,8 @@ var x = 0;
 >x : Symbol(x, Decl(inlineSourceMap.ts, 0, 3))
 
 console.log(x);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(inlineSourceMap.ts, 0, 3))
 
diff --git a/tests/baselines/reference/inlineSourceMap.types b/tests/baselines/reference/inlineSourceMap.types
index f6d478edf77..4194704936d 100644
--- a/tests/baselines/reference/inlineSourceMap.types
+++ b/tests/baselines/reference/inlineSourceMap.types
@@ -4,9 +4,9 @@ var x = 0;
 >0 : 0
 
 console.log(x);
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : number
 
diff --git a/tests/baselines/reference/inlineSourceMap2.errors.txt b/tests/baselines/reference/inlineSourceMap2.errors.txt
index ee60b349348..b9c1ab03e2d 100644
--- a/tests/baselines/reference/inlineSourceMap2.errors.txt
+++ b/tests/baselines/reference/inlineSourceMap2.errors.txt
@@ -1,14 +1,11 @@
 error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'.
 error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'.
-tests/cases/compiler/inlineSourceMap2.ts(4,1): error TS2304: Cannot find name 'console'.
 
 
 !!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'.
 !!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'.
-==== tests/cases/compiler/inlineSourceMap2.ts (1 errors) ====
+==== tests/cases/compiler/inlineSourceMap2.ts (0 errors) ====
     // configuration errors
     
     var x = 0;
-    console.log(x);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
\ No newline at end of file
+    console.log(x);
\ No newline at end of file
diff --git a/tests/baselines/reference/inlineSourceMap2.symbols b/tests/baselines/reference/inlineSourceMap2.symbols
index e1a4b77574d..3660b68bbe9 100644
--- a/tests/baselines/reference/inlineSourceMap2.symbols
+++ b/tests/baselines/reference/inlineSourceMap2.symbols
@@ -5,5 +5,8 @@ var x = 0;
 >x : Symbol(x, Decl(inlineSourceMap2.ts, 2, 3))
 
 console.log(x);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(inlineSourceMap2.ts, 2, 3))
 
diff --git a/tests/baselines/reference/inlineSourceMap2.types b/tests/baselines/reference/inlineSourceMap2.types
index 1593c4ee432..9a3a1f57af6 100644
--- a/tests/baselines/reference/inlineSourceMap2.types
+++ b/tests/baselines/reference/inlineSourceMap2.types
@@ -6,9 +6,9 @@ var x = 0;
 >0 : 0
 
 console.log(x);
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : number
 
diff --git a/tests/baselines/reference/inlineSources.errors.txt b/tests/baselines/reference/inlineSources.errors.txt
deleted file mode 100644
index ff72c35b867..00000000000
--- a/tests/baselines/reference/inlineSources.errors.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-tests/cases/compiler/a.ts(2,1): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/b.ts(2,1): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/a.ts (1 errors) ====
-    var a = 0;
-    console.log(a);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    
-==== tests/cases/compiler/b.ts (1 errors) ====
-    var b = 0;
-    console.log(b);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
\ No newline at end of file
diff --git a/tests/baselines/reference/inlineSources.symbols b/tests/baselines/reference/inlineSources.symbols
index ce2fce1e762..0da73fed123 100644
--- a/tests/baselines/reference/inlineSources.symbols
+++ b/tests/baselines/reference/inlineSources.symbols
@@ -3,6 +3,9 @@ var a = 0;
 >a : Symbol(a, Decl(a.ts, 0, 3))
 
 console.log(a);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(a.ts, 0, 3))
 
 === tests/cases/compiler/b.ts ===
@@ -10,5 +13,8 @@ var b = 0;
 >b : Symbol(b, Decl(b.ts, 0, 3))
 
 console.log(b);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(b.ts, 0, 3))
 
diff --git a/tests/baselines/reference/inlineSources.types b/tests/baselines/reference/inlineSources.types
index 5cb35846a46..8654347fbaf 100644
--- a/tests/baselines/reference/inlineSources.types
+++ b/tests/baselines/reference/inlineSources.types
@@ -4,10 +4,10 @@ var a = 0;
 >0 : 0
 
 console.log(a);
->console.log(a) : any
->console.log : any
->console : any
->log : any
+>console.log(a) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >a : number
 
 === tests/cases/compiler/b.ts ===
@@ -16,9 +16,9 @@ var b = 0;
 >0 : 0
 
 console.log(b);
->console.log(b) : any
->console.log : any
->console : any
->log : any
+>console.log(b) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >b : number
 
diff --git a/tests/baselines/reference/inlineSources2.errors.txt b/tests/baselines/reference/inlineSources2.errors.txt
deleted file mode 100644
index ff72c35b867..00000000000
--- a/tests/baselines/reference/inlineSources2.errors.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-tests/cases/compiler/a.ts(2,1): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/b.ts(2,1): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/a.ts (1 errors) ====
-    var a = 0;
-    console.log(a);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    
-==== tests/cases/compiler/b.ts (1 errors) ====
-    var b = 0;
-    console.log(b);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
\ No newline at end of file
diff --git a/tests/baselines/reference/inlineSources2.symbols b/tests/baselines/reference/inlineSources2.symbols
index ce2fce1e762..0da73fed123 100644
--- a/tests/baselines/reference/inlineSources2.symbols
+++ b/tests/baselines/reference/inlineSources2.symbols
@@ -3,6 +3,9 @@ var a = 0;
 >a : Symbol(a, Decl(a.ts, 0, 3))
 
 console.log(a);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(a.ts, 0, 3))
 
 === tests/cases/compiler/b.ts ===
@@ -10,5 +13,8 @@ var b = 0;
 >b : Symbol(b, Decl(b.ts, 0, 3))
 
 console.log(b);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(b.ts, 0, 3))
 
diff --git a/tests/baselines/reference/inlineSources2.types b/tests/baselines/reference/inlineSources2.types
index 5cb35846a46..8654347fbaf 100644
--- a/tests/baselines/reference/inlineSources2.types
+++ b/tests/baselines/reference/inlineSources2.types
@@ -4,10 +4,10 @@ var a = 0;
 >0 : 0
 
 console.log(a);
->console.log(a) : any
->console.log : any
->console : any
->log : any
+>console.log(a) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >a : number
 
 === tests/cases/compiler/b.ts ===
@@ -16,9 +16,9 @@ var b = 0;
 >0 : 0
 
 console.log(b);
->console.log(b) : any
->console.log : any
->console : any
->log : any
+>console.log(b) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >b : number
 
diff --git a/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols b/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols
index d3488b4db72..106f40ef3a9 100644
--- a/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols
+++ b/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols
@@ -5,7 +5,7 @@
 function f<T extends Date>() {
 >f : Symbol(f, Decl(innerTypeParameterShadowingOuterOne.ts, 0, 0))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     function g<T extends Number>() {
 >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 30))
@@ -34,9 +34,9 @@ function f<T extends Date>() {
 function f2<T extends Date, U extends Date>() {
 >f2 : Symbol(f2, Decl(innerTypeParameterShadowingOuterOne.ts, 10, 1))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 27))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     function g<T extends Number, U extends Number>() {
 >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 47))
diff --git a/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols b/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols
index 1a54ab4024a..d262182c029 100644
--- a/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols
+++ b/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols
@@ -5,7 +5,7 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(innerTypeParameterShadowingOuterOne2.ts, 0, 0))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     g<T extends Number>() {
 >g : Symbol(C.g, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 25))
@@ -39,9 +39,9 @@ class C<T extends Date> {
 class C2<T extends Date, U extends Date> {
 >C2 : Symbol(C2, Decl(innerTypeParameterShadowingOuterOne2.ts, 13, 1))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 24))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     g<T extends Number, U extends Number>() {
 >g : Symbol(C2.g, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 42))
diff --git a/tests/baselines/reference/intersectionTypeInference3.symbols b/tests/baselines/reference/intersectionTypeInference3.symbols
index 3945cf64fb6..dacf0e6d546 100644
--- a/tests/baselines/reference/intersectionTypeInference3.symbols
+++ b/tests/baselines/reference/intersectionTypeInference3.symbols
@@ -8,9 +8,9 @@ type Nominal<Kind extends string, Type> = Type & {
 >Type : Symbol(Type, Decl(intersectionTypeInference3.ts, 2, 33))
 
     [Symbol.species]: Kind;
->Symbol.species : Symbol(SymbolConstructor.species, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->species : Symbol(SymbolConstructor.species, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.species : Symbol(SymbolConstructor.species, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>species : Symbol(SymbolConstructor.species, Decl(lib.es6.d.ts, --, --))
 >Kind : Symbol(Kind, Decl(intersectionTypeInference3.ts, 2, 13))
 
 };
@@ -21,25 +21,25 @@ type A = Nominal<'A', string>;
 
 declare const a: Set<A>;
 >a : Symbol(a, Decl(intersectionTypeInference3.ts, 8, 13))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >A : Symbol(A, Decl(intersectionTypeInference3.ts, 4, 2))
 
 declare const b: Set<A>;
 >b : Symbol(b, Decl(intersectionTypeInference3.ts, 9, 13))
->Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >A : Symbol(A, Decl(intersectionTypeInference3.ts, 4, 2))
 
 const c1 = Array.from(a).concat(Array.from(b));
 >c1 : Symbol(c1, Decl(intersectionTypeInference3.ts, 11, 5))
->Array.from(a).concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from(a).concat : Symbol(Array.concat, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(intersectionTypeInference3.ts, 8, 13))
->concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>concat : Symbol(Array.concat, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >b : Symbol(b, Decl(intersectionTypeInference3.ts, 9, 13))
 
 // Simpler repro
@@ -51,7 +51,7 @@ declare function from<T>(): T[];
 
 const c2: ReadonlyArray<A> = from();
 >c2 : Symbol(c2, Decl(intersectionTypeInference3.ts, 16, 5))
->ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >A : Symbol(A, Decl(intersectionTypeInference3.ts, 4, 2))
 >from : Symbol(from, Decl(intersectionTypeInference3.ts, 11, 47))
 
diff --git a/tests/baselines/reference/intersectionTypeInference3.types b/tests/baselines/reference/intersectionTypeInference3.types
index 9fca37af8c1..0e1816ded14 100644
--- a/tests/baselines/reference/intersectionTypeInference3.types
+++ b/tests/baselines/reference/intersectionTypeInference3.types
@@ -34,15 +34,15 @@ const c1 = Array.from(a).concat(Array.from(b));
 >Array.from(a).concat(Array.from(b)) : Nominal<"A", string>[]
 >Array.from(a).concat : { (...items: ReadonlyArray<Nominal<"A", string>>[]): Nominal<"A", string>[]; (...items: (Nominal<"A", string> | ReadonlyArray<Nominal<"A", string>>)[]): Nominal<"A", string>[]; }
 >Array.from(a) : Nominal<"A", string>[]
->Array.from : { <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
+>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
->from : { <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
+>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >a : Set<Nominal<"A", string>>
 >concat : { (...items: ReadonlyArray<Nominal<"A", string>>[]): Nominal<"A", string>[]; (...items: (Nominal<"A", string> | ReadonlyArray<Nominal<"A", string>>)[]): Nominal<"A", string>[]; }
 >Array.from(b) : Nominal<"A", string>[]
->Array.from : { <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
+>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
->from : { <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
+>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >b : Set<Nominal<"A", string>>
 
 // Simpler repro
diff --git a/tests/baselines/reference/invalidReturnStatements.symbols b/tests/baselines/reference/invalidReturnStatements.symbols
index 138e4343291..1d7a7cd3ec5 100644
--- a/tests/baselines/reference/invalidReturnStatements.symbols
+++ b/tests/baselines/reference/invalidReturnStatements.symbols
@@ -11,7 +11,7 @@ function fn3(): boolean { }
 
 function fn4(): Date {  }
 >fn4 : Symbol(fn4, Decl(invalidReturnStatements.ts, 3, 27))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn7(): any {  } // should be valid: any includes void
 >fn7 : Symbol(fn7, Decl(invalidReturnStatements.ts, 4, 25))
diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols
index b901b43b7b9..12d0d36d4cc 100644
--- a/tests/baselines/reference/iterableArrayPattern1.symbols
+++ b/tests/baselines/reference/iterableArrayPattern1.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern1.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iterableArrayPattern1.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 0))
diff --git a/tests/baselines/reference/iterableArrayPattern10.symbols b/tests/baselines/reference/iterableArrayPattern10.symbols
index 12f5c1b3cb7..2519fdf0837 100644
--- a/tests/baselines/reference/iterableArrayPattern10.symbols
+++ b/tests/baselines/reference/iterableArrayPattern10.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern10.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols
index 36871283fbf..dd204d6d261 100644
--- a/tests/baselines/reference/iterableArrayPattern11.symbols
+++ b/tests/baselines/reference/iterableArrayPattern11.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols
index cb876370876..105d9236f25 100644
--- a/tests/baselines/reference/iterableArrayPattern12.symbols
+++ b/tests/baselines/reference/iterableArrayPattern12.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols
index 25241ab24b8..563bc7d1145 100644
--- a/tests/baselines/reference/iterableArrayPattern13.symbols
+++ b/tests/baselines/reference/iterableArrayPattern13.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern14.symbols b/tests/baselines/reference/iterableArrayPattern14.symbols
index 7479c8f0857..4ae0ce6b746 100644
--- a/tests/baselines/reference/iterableArrayPattern14.symbols
+++ b/tests/baselines/reference/iterableArrayPattern14.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern14.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern15.symbols b/tests/baselines/reference/iterableArrayPattern15.symbols
index 98a1c9e5c5d..b1b5ab0cbe9 100644
--- a/tests/baselines/reference/iterableArrayPattern15.symbols
+++ b/tests/baselines/reference/iterableArrayPattern15.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern15.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern16.symbols b/tests/baselines/reference/iterableArrayPattern16.symbols
index 59b8ee70562..ee1381b125f 100644
--- a/tests/baselines/reference/iterableArrayPattern16.symbols
+++ b/tests/baselines/reference/iterableArrayPattern16.symbols
@@ -37,9 +37,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern16.ts, 3, 27))
@@ -64,9 +64,9 @@ class FooIteratorIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIteratorIterator, Decl(iterableArrayPattern16.ts, 15, 1))
diff --git a/tests/baselines/reference/iterableArrayPattern17.symbols b/tests/baselines/reference/iterableArrayPattern17.symbols
index 1312aded6a1..668339c8581 100644
--- a/tests/baselines/reference/iterableArrayPattern17.symbols
+++ b/tests/baselines/reference/iterableArrayPattern17.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern17.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern18.symbols b/tests/baselines/reference/iterableArrayPattern18.symbols
index c928f068c65..aa66773a5e7 100644
--- a/tests/baselines/reference/iterableArrayPattern18.symbols
+++ b/tests/baselines/reference/iterableArrayPattern18.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern18.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern19.symbols b/tests/baselines/reference/iterableArrayPattern19.symbols
index 9d5caeb43d5..a1218e9478c 100644
--- a/tests/baselines/reference/iterableArrayPattern19.symbols
+++ b/tests/baselines/reference/iterableArrayPattern19.symbols
@@ -26,9 +26,9 @@ class FooArrayIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooArrayIterator, Decl(iterableArrayPattern19.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols
index db700cdd572..f9aa29a9319 100644
--- a/tests/baselines/reference/iterableArrayPattern2.symbols
+++ b/tests/baselines/reference/iterableArrayPattern2.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern2.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iterableArrayPattern2.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 0))
diff --git a/tests/baselines/reference/iterableArrayPattern20.symbols b/tests/baselines/reference/iterableArrayPattern20.symbols
index 6649bf547cf..41e09a69eec 100644
--- a/tests/baselines/reference/iterableArrayPattern20.symbols
+++ b/tests/baselines/reference/iterableArrayPattern20.symbols
@@ -26,9 +26,9 @@ class FooArrayIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooArrayIterator, Decl(iterableArrayPattern20.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern25.symbols b/tests/baselines/reference/iterableArrayPattern25.symbols
index 1450f8539cf..a0a84b0898c 100644
--- a/tests/baselines/reference/iterableArrayPattern25.symbols
+++ b/tests/baselines/reference/iterableArrayPattern25.symbols
@@ -8,5 +8,5 @@ function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
 
 takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
 >takeFirstTwoEntries : Symbol(takeFirstTwoEntries, Decl(iterableArrayPattern25.ts, 0, 0))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iterableArrayPattern26.symbols b/tests/baselines/reference/iterableArrayPattern26.symbols
index f67e7b861d2..cac9d55522e 100644
--- a/tests/baselines/reference/iterableArrayPattern26.symbols
+++ b/tests/baselines/reference/iterableArrayPattern26.symbols
@@ -8,5 +8,5 @@ function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
 
 takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
 >takeFirstTwoEntries : Symbol(takeFirstTwoEntries, Decl(iterableArrayPattern26.ts, 0, 0))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iterableArrayPattern27.symbols b/tests/baselines/reference/iterableArrayPattern27.symbols
index 58e34b35954..ec46e3ba8dc 100644
--- a/tests/baselines/reference/iterableArrayPattern27.symbols
+++ b/tests/baselines/reference/iterableArrayPattern27.symbols
@@ -8,5 +8,5 @@ function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
 
 takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]]));
 >takeFirstTwoEntries : Symbol(takeFirstTwoEntries, Decl(iterableArrayPattern27.ts, 0, 0))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iterableArrayPattern29.symbols b/tests/baselines/reference/iterableArrayPattern29.symbols
index 690685b857a..aca17d23757 100644
--- a/tests/baselines/reference/iterableArrayPattern29.symbols
+++ b/tests/baselines/reference/iterableArrayPattern29.symbols
@@ -8,5 +8,5 @@ function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
 
 takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
 >takeFirstTwoEntries : Symbol(takeFirstTwoEntries, Decl(iterableArrayPattern29.ts, 0, 0))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols
index a82c5f5e025..9a67ae2b30b 100644
--- a/tests/baselines/reference/iterableArrayPattern3.symbols
+++ b/tests/baselines/reference/iterableArrayPattern3.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols
index b6597922490..1d0ccdee791 100644
--- a/tests/baselines/reference/iterableArrayPattern30.symbols
+++ b/tests/baselines/reference/iterableArrayPattern30.symbols
@@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11))
 >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18))
 >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21))
->Map : Symbol(Map, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Map : Symbol(Map, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols
index 6a3526a3482..06061b341e2 100644
--- a/tests/baselines/reference/iterableArrayPattern4.symbols
+++ b/tests/baselines/reference/iterableArrayPattern4.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern5.symbols b/tests/baselines/reference/iterableArrayPattern5.symbols
index edfcbce076d..2c6681b24a4 100644
--- a/tests/baselines/reference/iterableArrayPattern5.symbols
+++ b/tests/baselines/reference/iterableArrayPattern5.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern5.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern6.symbols b/tests/baselines/reference/iterableArrayPattern6.symbols
index 797f7770b89..a81a9c050e7 100644
--- a/tests/baselines/reference/iterableArrayPattern6.symbols
+++ b/tests/baselines/reference/iterableArrayPattern6.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern6.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern7.symbols b/tests/baselines/reference/iterableArrayPattern7.symbols
index 6faf9adcf13..5fae7dcd262 100644
--- a/tests/baselines/reference/iterableArrayPattern7.symbols
+++ b/tests/baselines/reference/iterableArrayPattern7.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern7.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern8.symbols b/tests/baselines/reference/iterableArrayPattern8.symbols
index 035b391d38b..c7ff7bd5221 100644
--- a/tests/baselines/reference/iterableArrayPattern8.symbols
+++ b/tests/baselines/reference/iterableArrayPattern8.symbols
@@ -26,9 +26,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern8.ts, 1, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols
index d85329c4507..9eed20bfbda 100644
--- a/tests/baselines/reference/iterableArrayPattern9.symbols
+++ b/tests/baselines/reference/iterableArrayPattern9.symbols
@@ -32,9 +32,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27))
diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols
index 7a7f77e7898..29e3a5b2070 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -1,10 +1,10 @@
 === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts ===
 var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
->s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>s.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols
index 6d6656f0f71..6afd84fd556 100644
--- a/tests/baselines/reference/iteratorSpreadInArray.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 0))
diff --git a/tests/baselines/reference/iteratorSpreadInArray10.symbols b/tests/baselines/reference/iteratorSpreadInArray10.symbols
index f2aa6fab527..b6e56f8157e 100644
--- a/tests/baselines/reference/iteratorSpreadInArray10.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray10.symbols
@@ -3,9 +3,9 @@ class SymbolIterator {
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInArray10.ts, 0, 0))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray10.ts, 0, 0))
diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols
index 6194a8305aa..70d46097c90 100644
--- a/tests/baselines/reference/iteratorSpreadInArray11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 
 var array = [...iter];
 >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3))
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols
index 6fd22547ee6..9df3f2683be 100644
--- a/tests/baselines/reference/iteratorSpreadInArray2.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 0))
@@ -43,9 +43,9 @@ class NumberIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 11, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols
index ff6bc66e9d3..62caffc1c29 100644
--- a/tests/baselines/reference/iteratorSpreadInArray3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 0))
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols
index 16fa1c62c6c..827f87a81b8 100644
--- a/tests/baselines/reference/iteratorSpreadInArray4.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 0))
diff --git a/tests/baselines/reference/iteratorSpreadInArray5.symbols b/tests/baselines/reference/iteratorSpreadInArray5.symbols
index 36174db94e7..aaad4ee499e 100644
--- a/tests/baselines/reference/iteratorSpreadInArray5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray5.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray5.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray5.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray5.ts, 0, 0))
diff --git a/tests/baselines/reference/iteratorSpreadInArray6.symbols b/tests/baselines/reference/iteratorSpreadInArray6.symbols
index ab01672156d..361259f47ea 100644
--- a/tests/baselines/reference/iteratorSpreadInArray6.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray6.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray6.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray6.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray6.ts, 0, 0))
@@ -30,8 +30,8 @@ var array: number[] = [0, 1];
 >array : Symbol(array, Decl(iteratorSpreadInArray6.ts, 13, 3))
 
 array.concat([...new SymbolIterator]);
->array.concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>array.concat : Symbol(Array.concat, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >array : Symbol(array, Decl(iteratorSpreadInArray6.ts, 13, 3))
->concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>concat : Symbol(Array.concat, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInArray6.ts, 0, 0))
 
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols
index 534741a62a6..dd206b20e89 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 3, 28))
@@ -17,9 +17,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 0, 0))
@@ -30,8 +30,8 @@ var array: symbol[];
 >array : Symbol(array, Decl(iteratorSpreadInArray7.ts, 13, 3))
 
 array.concat([...new SymbolIterator]);
->array.concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>array.concat : Symbol(Array.concat, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >array : Symbol(array, Decl(iteratorSpreadInArray7.ts, 13, 3))
->concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>concat : Symbol(Array.concat, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 0, 0))
 
diff --git a/tests/baselines/reference/iteratorSpreadInArray8.symbols b/tests/baselines/reference/iteratorSpreadInArray8.symbols
index 3555c918ac1..678ede19e93 100644
--- a/tests/baselines/reference/iteratorSpreadInArray8.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray8.symbols
@@ -8,7 +8,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray8.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray8.ts, 3, 28))
diff --git a/tests/baselines/reference/iteratorSpreadInArray9.symbols b/tests/baselines/reference/iteratorSpreadInArray9.symbols
index a5564e9773d..73d4a00fb7f 100644
--- a/tests/baselines/reference/iteratorSpreadInArray9.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray9.symbols
@@ -8,15 +8,15 @@ class SymbolIterator {
         return {
             value: Symbol()
 >value : Symbol(value, Decl(iteratorSpreadInArray9.ts, 2, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         };
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray9.ts, 0, 0))
diff --git a/tests/baselines/reference/iteratorSpreadInCall.symbols b/tests/baselines/reference/iteratorSpreadInCall.symbols
index 372fc25e8e6..bc0258188d7 100644
--- a/tests/baselines/reference/iteratorSpreadInCall.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall.ts, 4, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall.ts, 0, 27))
diff --git a/tests/baselines/reference/iteratorSpreadInCall10.symbols b/tests/baselines/reference/iteratorSpreadInCall10.symbols
index 3ee60f7c58f..bc6aeda90f4 100644
--- a/tests/baselines/reference/iteratorSpreadInCall10.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall10.symbols
@@ -15,7 +15,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall10.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall10.ts, 4, 28))
@@ -24,9 +24,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall10.ts, 0, 39))
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols
index b6db07942d0..d3dade2a691 100644
--- a/tests/baselines/reference/iteratorSpreadInCall11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols
@@ -15,7 +15,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 4, 28))
@@ -24,9 +24,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 0, 42))
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols
index 983ab8fcd90..59a64e24824 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 6, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 7, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 2, 1))
@@ -52,9 +52,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall2.symbols b/tests/baselines/reference/iteratorSpreadInCall2.symbols
index bf0f71c4fd5..4e9cc9f2885 100644
--- a/tests/baselines/reference/iteratorSpreadInCall2.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall2.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall2.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall2.ts, 4, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall2.ts, 0, 29))
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols
index d8f414bcd72..90198d39e6b 100644
--- a/tests/baselines/reference/iteratorSpreadInCall3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 4, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 0, 32))
diff --git a/tests/baselines/reference/iteratorSpreadInCall4.symbols b/tests/baselines/reference/iteratorSpreadInCall4.symbols
index b811baa0083..0e3fe54ad08 100644
--- a/tests/baselines/reference/iteratorSpreadInCall4.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall4.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall4.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall4.ts, 4, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall4.ts, 0, 44))
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols
index 81143b79f29..aae75367c94 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 4, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 0, 43))
@@ -47,9 +47,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.symbols b/tests/baselines/reference/iteratorSpreadInCall6.symbols
index d41a3fcea46..6fbea8bcca4 100644
--- a/tests/baselines/reference/iteratorSpreadInCall6.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall6.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall6.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall6.ts, 4, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall6.ts, 0, 43))
@@ -47,9 +47,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.symbols b/tests/baselines/reference/iteratorSpreadInCall7.symbols
index a0e62299ae9..d27bf61a3ea 100644
--- a/tests/baselines/reference/iteratorSpreadInCall7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall7.symbols
@@ -15,7 +15,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall7.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall7.ts, 4, 28))
@@ -24,9 +24,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall7.ts, 0, 43))
@@ -50,9 +50,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.symbols b/tests/baselines/reference/iteratorSpreadInCall8.symbols
index bd84d77686e..a99b348386e 100644
--- a/tests/baselines/reference/iteratorSpreadInCall8.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall8.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall8.ts, 6, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall8.ts, 7, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall8.ts, 2, 1))
@@ -52,9 +52,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.symbols b/tests/baselines/reference/iteratorSpreadInCall9.symbols
index 70486768d4d..d9f1e2a5970 100644
--- a/tests/baselines/reference/iteratorSpreadInCall9.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall9.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall9.ts, 6, 16))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall9.ts, 7, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall9.ts, 2, 1))
@@ -52,9 +52,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
diff --git a/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols b/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols
index fb75206a825..0aa0bf641d8 100644
--- a/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols
+++ b/tests/baselines/reference/iteratorsAndStrictNullChecks.symbols
@@ -4,9 +4,9 @@ for (const x of ["a", "b"]) {
 >x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 1, 10))
 
     x.substring;
->x.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>x.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(iteratorsAndStrictNullChecks.ts, 1, 10))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 // Spread
@@ -17,8 +17,8 @@ const ys = [4, 5];
 >ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 7, 5))
 
 xs.push(...ys);
->xs.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>xs.push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >xs : Symbol(xs, Decl(iteratorsAndStrictNullChecks.ts, 6, 5))
->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >ys : Symbol(ys, Decl(iteratorsAndStrictNullChecks.ts, 7, 5))
 
diff --git a/tests/baselines/reference/jsxEmitWithAttributes.symbols b/tests/baselines/reference/jsxEmitWithAttributes.symbols
index f20470ebb6b..88670c2eb0e 100644
--- a/tests/baselines/reference/jsxEmitWithAttributes.symbols
+++ b/tests/baselines/reference/jsxEmitWithAttributes.symbols
@@ -68,12 +68,12 @@ function toCamelCase(text: string): string {
 >text : Symbol(text, Decl(Element.ts, 26, 21))
 
     return text[0].toLowerCase() + text.substring(1);
->text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
+>text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
->text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
+>text.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 === tests/cases/compiler/test.tsx ===
diff --git a/tests/baselines/reference/jsxFactoryAndReactNamespace.symbols b/tests/baselines/reference/jsxFactoryAndReactNamespace.symbols
index f20470ebb6b..88670c2eb0e 100644
--- a/tests/baselines/reference/jsxFactoryAndReactNamespace.symbols
+++ b/tests/baselines/reference/jsxFactoryAndReactNamespace.symbols
@@ -68,12 +68,12 @@ function toCamelCase(text: string): string {
 >text : Symbol(text, Decl(Element.ts, 26, 21))
 
     return text[0].toLowerCase() + text.substring(1);
->text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
+>text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
->text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
+>text.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 === tests/cases/compiler/test.tsx ===
diff --git a/tests/baselines/reference/jsxFactoryIdentifier.symbols b/tests/baselines/reference/jsxFactoryIdentifier.symbols
index b66976f8884..380a45d2a91 100644
--- a/tests/baselines/reference/jsxFactoryIdentifier.symbols
+++ b/tests/baselines/reference/jsxFactoryIdentifier.symbols
@@ -68,12 +68,12 @@ function toCamelCase(text: string): string {
 >text : Symbol(text, Decl(Element.ts, 26, 21))
 
     return text[0].toLowerCase() + text.substring(1);
->text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
+>text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
->text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
+>text.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 === tests/cases/compiler/test.tsx ===
diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.symbols b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.symbols
index f20470ebb6b..88670c2eb0e 100644
--- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.symbols
+++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.symbols
@@ -68,12 +68,12 @@ function toCamelCase(text: string): string {
 >text : Symbol(text, Decl(Element.ts, 26, 21))
 
     return text[0].toLowerCase() + text.substring(1);
->text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
+>text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
->text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
+>text.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 === tests/cases/compiler/test.tsx ===
diff --git a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.symbols b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.symbols
index f20470ebb6b..88670c2eb0e 100644
--- a/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.symbols
+++ b/tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.symbols
@@ -68,12 +68,12 @@ function toCamelCase(text: string): string {
 >text : Symbol(text, Decl(Element.ts, 26, 21))
 
     return text[0].toLowerCase() + text.substring(1);
->text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
+>text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
->text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
+>text.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 === tests/cases/compiler/test.tsx ===
diff --git a/tests/baselines/reference/jsxFactoryQualifiedName.symbols b/tests/baselines/reference/jsxFactoryQualifiedName.symbols
index f20470ebb6b..88670c2eb0e 100644
--- a/tests/baselines/reference/jsxFactoryQualifiedName.symbols
+++ b/tests/baselines/reference/jsxFactoryQualifiedName.symbols
@@ -68,12 +68,12 @@ function toCamelCase(text: string): string {
 >text : Symbol(text, Decl(Element.ts, 26, 21))
 
     return text[0].toLowerCase() + text.substring(1);
->text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
+>text[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
->text.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es6.d.ts, --, --))
+>text.substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 >text : Symbol(text, Decl(Element.ts, 26, 21))
->substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es6.d.ts, --, --))
 }
 
 === tests/cases/compiler/test.tsx ===
diff --git a/tests/baselines/reference/lambdaArgCrash.symbols b/tests/baselines/reference/lambdaArgCrash.symbols
index 76f3f705135..dc1187f4be5 100644
--- a/tests/baselines/reference/lambdaArgCrash.symbols
+++ b/tests/baselines/reference/lambdaArgCrash.symbols
@@ -25,11 +25,11 @@ class Event {
 		 /// <param name="listener">The callback function to register.</param>
 
 		 this._listeners.push(listener);
->this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this._listeners.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this._listeners : Symbol(Event._listeners, Decl(lambdaArgCrash.ts, 0, 13))
 >this : Symbol(Event, Decl(lambdaArgCrash.ts, 0, 0))
 >_listeners : Symbol(Event._listeners, Decl(lambdaArgCrash.ts, 0, 13))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >listener : Symbol(listener, Decl(lambdaArgCrash.ts, 12, 6))
 
 	}
diff --git a/tests/baselines/reference/letConstInCaseClauses.errors.txt b/tests/baselines/reference/letConstInCaseClauses.errors.txt
index ae56fe47a79..ec075327d5a 100644
--- a/tests/baselines/reference/letConstInCaseClauses.errors.txt
+++ b/tests/baselines/reference/letConstInCaseClauses.errors.txt
@@ -1,18 +1,14 @@
-tests/cases/compiler/letConstInCaseClauses.ts(6,5): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/letConstInCaseClauses.ts(20,5): error TS2304: Cannot find name 'console'.
 tests/cases/compiler/letConstInCaseClauses.ts(22,14): error TS2678: Type '10' is not comparable to type '1'.
 tests/cases/compiler/letConstInCaseClauses.ts(26,14): error TS2678: Type '10' is not comparable to type '2'.
 
 
-==== tests/cases/compiler/letConstInCaseClauses.ts (4 errors) ====
+==== tests/cases/compiler/letConstInCaseClauses.ts (2 errors) ====
     var x = 10;
     var y = 20;
     {
         let x = 1;
         let y = 2;
         console.log(x)
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
         switch (x) {
             case 10:
                 let x = 20;
@@ -27,8 +23,6 @@ tests/cases/compiler/letConstInCaseClauses.ts(26,14): error TS2678: Type '10' is
         const x = 1;
         const y = 2;
         console.log(x)
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
         switch (x) {
             case 10:
                  ~~
diff --git a/tests/baselines/reference/letConstInCaseClauses.symbols b/tests/baselines/reference/letConstInCaseClauses.symbols
index 4d71a465b1e..23bf9dc6553 100644
--- a/tests/baselines/reference/letConstInCaseClauses.symbols
+++ b/tests/baselines/reference/letConstInCaseClauses.symbols
@@ -12,6 +12,9 @@ var y = 20;
 >y : Symbol(y, Decl(letConstInCaseClauses.ts, 4, 7))
 
     console.log(x)
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(letConstInCaseClauses.ts, 3, 7))
 
     switch (x) {
@@ -38,6 +41,9 @@ var y = 20;
 >y : Symbol(y, Decl(letConstInCaseClauses.ts, 18, 9))
 
     console.log(x)
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(letConstInCaseClauses.ts, 17, 9))
 
     switch (x) {
diff --git a/tests/baselines/reference/letConstInCaseClauses.types b/tests/baselines/reference/letConstInCaseClauses.types
index 5db4f3158dc..5f09eaba7ed 100644
--- a/tests/baselines/reference/letConstInCaseClauses.types
+++ b/tests/baselines/reference/letConstInCaseClauses.types
@@ -16,10 +16,10 @@ var y = 20;
 >2 : 2
 
     console.log(x)
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : number
 
     switch (x) {
@@ -54,10 +54,10 @@ var y = 20;
 >2 : 2
 
     console.log(x)
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : 1
 
     switch (x) {
diff --git a/tests/baselines/reference/letDeclarations-access.symbols b/tests/baselines/reference/letDeclarations-access.symbols
index 31a64fab3f8..eb1f0c85802 100644
--- a/tests/baselines/reference/letDeclarations-access.symbols
+++ b/tests/baselines/reference/letDeclarations-access.symbols
@@ -80,7 +80,7 @@ x;
 >x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3))
 
 x.toString();
->x.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>x.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(letDeclarations-access.ts, 0, 3))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/letShadowedByNameInNestedScope.errors.txt b/tests/baselines/reference/letShadowedByNameInNestedScope.errors.txt
deleted file mode 100644
index b47e194f93e..00000000000
--- a/tests/baselines/reference/letShadowedByNameInNestedScope.errors.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-tests/cases/compiler/letShadowedByNameInNestedScope.ts(6,9): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/compiler/letShadowedByNameInNestedScope.ts (1 errors) ====
-    var x;
-    function foo() {
-        let x = 0;
-        (function () {
-            var _x = 1;
-            console.log(x);
-            ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-        })();
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/letShadowedByNameInNestedScope.symbols b/tests/baselines/reference/letShadowedByNameInNestedScope.symbols
index 3f1b021ccad..98b6d1fe8a4 100644
--- a/tests/baselines/reference/letShadowedByNameInNestedScope.symbols
+++ b/tests/baselines/reference/letShadowedByNameInNestedScope.symbols
@@ -13,6 +13,9 @@ function foo() {
 >_x : Symbol(_x, Decl(letShadowedByNameInNestedScope.ts, 4, 11))
 
         console.log(x);
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(letShadowedByNameInNestedScope.ts, 2, 7))
 
     })();
diff --git a/tests/baselines/reference/letShadowedByNameInNestedScope.types b/tests/baselines/reference/letShadowedByNameInNestedScope.types
index 9f7636aa2cc..925769d5359 100644
--- a/tests/baselines/reference/letShadowedByNameInNestedScope.types
+++ b/tests/baselines/reference/letShadowedByNameInNestedScope.types
@@ -19,10 +19,10 @@ function foo() {
 >1 : 1
 
         console.log(x);
->console.log(x) : any
->console.log : any
->console : any
->log : any
+>console.log(x) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >x : number
 
     })();
diff --git a/tests/baselines/reference/libdtsFix.symbols b/tests/baselines/reference/libdtsFix.symbols
index 5399b7150e4..f3b6b014de5 100644
--- a/tests/baselines/reference/libdtsFix.symbols
+++ b/tests/baselines/reference/libdtsFix.symbols
@@ -1,6 +1,6 @@
 === tests/cases/compiler/libdtsFix.ts ===
 interface HTMLElement {
->HTMLElement : Symbol(HTMLElement, Decl(libdtsFix.ts, 0, 0))
+>HTMLElement : Symbol(HTMLElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(libdtsFix.ts, 0, 0))
 
     type: string;
 >type : Symbol(HTMLElement.type, Decl(libdtsFix.ts, 0, 23))
diff --git a/tests/baselines/reference/library-reference-2.trace.json b/tests/baselines/reference/library-reference-2.trace.json
index e708d11c464..d48ca68145d 100644
--- a/tests/baselines/reference/library-reference-2.trace.json
+++ b/tests/baselines/reference/library-reference-2.trace.json
@@ -7,7 +7,7 @@
     "File '/types/jquery/jquery.d.ts' exist - use it as a name resolution result.",
     "Resolving real path for '/types/jquery/jquery.d.ts', result '/types/jquery/jquery.d.ts'.",
     "======== Type reference directive 'jquery' was successfully resolved to '/types/jquery/jquery.d.ts', primary: true. ========",
-    "======== Resolving type reference directive 'jquery', containing file 'test/__inferred type names__.ts', root directory '/types'. ========",
+    "======== Resolving type reference directive 'jquery', containing file '/test/__inferred type names__.ts', root directory '/types'. ========",
     "Resolving with primary search path '/types'.",
     "Found 'package.json' at '/types/jquery/package.json'.",
     "'package.json' does not have a 'typings' field.",
diff --git a/tests/baselines/reference/library_DatePrototypeProperties.symbols b/tests/baselines/reference/library_DatePrototypeProperties.symbols
index 1b725fbf84c..d35c2b6ab37 100644
--- a/tests/baselines/reference/library_DatePrototypeProperties.symbols
+++ b/tests/baselines/reference/library_DatePrototypeProperties.symbols
@@ -4,308 +4,308 @@
 Date.prototype.constructor;
 >Date.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --))
 
 Date.prototype.toString();
 >Date.prototype.toString : Symbol(Date.toString, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toString : Symbol(Date.toString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toDateString();
 >Date.prototype.toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toTimeString();
 >Date.prototype.toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toLocaleString();
 >Date.prototype.toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 Date.prototype.toLocaleDateString();
 >Date.prototype.toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 Date.prototype.toLocaleTimeString();
 >Date.prototype.toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 Date.prototype.valueOf();
 >Date.prototype.valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, --, --))
 
 Date.prototype.getTime();
 >Date.prototype.getTime : Symbol(Date.getTime, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getTime : Symbol(Date.getTime, Decl(lib.d.ts, --, --))
 
 Date.prototype.getFullYear();
 >Date.prototype.getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCFullYear();
 >Date.prototype.getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.getMonth();
 >Date.prototype.getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCMonth();
 >Date.prototype.getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.getDate();
 >Date.prototype.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCDate();
 >Date.prototype.getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.getDay();
 >Date.prototype.getDay : Symbol(Date.getDay, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getDay : Symbol(Date.getDay, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCDay();
 >Date.prototype.getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, --, --))
 
 Date.prototype.getHours();
 >Date.prototype.getHours : Symbol(Date.getHours, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getHours : Symbol(Date.getHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCHours();
 >Date.prototype.getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.getMinutes();
 >Date.prototype.getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCMinutes();
 >Date.prototype.getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.getSeconds();
 >Date.prototype.getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCSeconds();
 >Date.prototype.getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getMilliseconds();
 >Date.prototype.getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCMilliseconds();
 >Date.prototype.getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getTimezoneOffset();
 >Date.prototype.getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, --, --))
 
 Date.prototype.setTime(0);
 >Date.prototype.setTime : Symbol(Date.setTime, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setTime : Symbol(Date.setTime, Decl(lib.d.ts, --, --))
 
 Date.prototype.setMilliseconds(0);
 >Date.prototype.setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCMilliseconds(0);
 >Date.prototype.setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setSeconds(0);
 >Date.prototype.setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCSeconds(0);
 >Date.prototype.setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setMinutes(0);
 >Date.prototype.setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCMinutes(0);
 >Date.prototype.setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.setHours(0);
 >Date.prototype.setHours : Symbol(Date.setHours, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setHours : Symbol(Date.setHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCHours(0);
 >Date.prototype.setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.setDate(0);
 >Date.prototype.setDate : Symbol(Date.setDate, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setDate : Symbol(Date.setDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCDate(0);
 >Date.prototype.setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.setMonth(0);
 >Date.prototype.setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCMonth(0);
 >Date.prototype.setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.setFullYear(0);
 >Date.prototype.setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCFullYear(0);
 >Date.prototype.setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.toUTCString();
 >Date.prototype.toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toISOString();
 >Date.prototype.toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toJSON(null);
 >Date.prototype.toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, --, --))
 >Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
 >toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/localClassesInLoop_ES6.symbols b/tests/baselines/reference/localClassesInLoop_ES6.symbols
index 582eca51f04..d034881f1e4 100644
--- a/tests/baselines/reference/localClassesInLoop_ES6.symbols
+++ b/tests/baselines/reference/localClassesInLoop_ES6.symbols
@@ -16,9 +16,9 @@ for (let x = 0; x < 2; ++x) {
 >C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 4, 29))
 
     data.push(() => C);
->data.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>data.push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >data : Symbol(data, Decl(localClassesInLoop_ES6.ts, 3, 3))
->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es6.d.ts, --, --))
 >C : Symbol(C, Decl(localClassesInLoop_ES6.ts, 4, 29))
 }
 
diff --git a/tests/baselines/reference/localTypes5.symbols b/tests/baselines/reference/localTypes5.symbols
index 175469e7a72..dc0e3c80120 100644
--- a/tests/baselines/reference/localTypes5.symbols
+++ b/tests/baselines/reference/localTypes5.symbols
@@ -22,7 +22,7 @@ function foo<A>() {
 >Y : Symbol(Y, Decl(localTypes5.ts, 3, 36))
 
             })<Date>();
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
         }
     }
     var x = new X();
diff --git a/tests/baselines/reference/mappedTypeErrors.symbols b/tests/baselines/reference/mappedTypeErrors.symbols
index 38d0a0bc72f..2e4ddb47cbf 100644
--- a/tests/baselines/reference/mappedTypeErrors.symbols
+++ b/tests/baselines/reference/mappedTypeErrors.symbols
@@ -46,12 +46,12 @@ type T01 = { [P in number]: string };  // Error
 type T02 = { [P in Date]: number };  // Error
 >T02 : Symbol(T02, Decl(mappedTypeErrors.ts, 19, 37))
 >P : Symbol(P, Decl(mappedTypeErrors.ts, 20, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type T03 = Record<Date, number>;  // Error
 >T03 : Symbol(T03, Decl(mappedTypeErrors.ts, 20, 35))
 >Record : Symbol(Record, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type T10 = Pick<Shape, "name">;
 >T10 : Symbol(T10, Decl(mappedTypeErrors.ts, 21, 32))
diff --git a/tests/baselines/reference/mappedTypes1.symbols b/tests/baselines/reference/mappedTypes1.symbols
index e012b49ddf4..8cafc799d84 100644
--- a/tests/baselines/reference/mappedTypes1.symbols
+++ b/tests/baselines/reference/mappedTypes1.symbols
@@ -24,7 +24,7 @@ type T03 = { [P in keyof Item]: Date };
 >T03 : Symbol(T03, Decl(mappedTypes1.ts, 4, 41))
 >P : Symbol(P, Decl(mappedTypes1.ts, 5, 14))
 >Item : Symbol(Item, Decl(mappedTypes1.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type T10 = { [P in keyof Item]: Item[P] };
 >T10 : Symbol(T10, Decl(mappedTypes1.ts, 5, 39))
diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols
index bb197a97aeb..3e5cabf4184 100644
--- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols
+++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols
@@ -11,7 +11,7 @@ interface C extends D {
 
 	b(): Date;
 >b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var c:C;
@@ -38,7 +38,7 @@ var d: number = c.a();
 
 var e: Date = c.b();
 >e : Symbol(e, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 12, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c.b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23))
 >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3))
 >b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23))
diff --git a/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols b/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols
index de2bff45743..e38829534b2 100644
--- a/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols
+++ b/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols
@@ -69,7 +69,7 @@ class D implements A<boolean> {
 
     b: Date;
 >b : Symbol(D.b, Decl(mergedInterfacesWithMultipleBases3.ts, 28, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     c: string;
 >c : Symbol(D.c, Decl(mergedInterfacesWithMultipleBases3.ts, 29, 12))
diff --git a/tests/baselines/reference/mixinClassesAnonymous.symbols b/tests/baselines/reference/mixinClassesAnonymous.symbols
index bd709501f31..d65b103f8d1 100644
--- a/tests/baselines/reference/mixinClassesAnonymous.symbols
+++ b/tests/baselines/reference/mixinClassesAnonymous.symbols
@@ -181,7 +181,7 @@ const Timestamped = <CT extends Constructor<object>>(Base: CT) => {
 
         timestamp = new Date();
 >timestamp : Symbol((Anonymous class).timestamp, Decl(mixinClassesAnonymous.ts, 60, 31))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     };
 }
diff --git a/tests/baselines/reference/multiExtendsSplitInterfaces1.errors.txt b/tests/baselines/reference/multiExtendsSplitInterfaces1.errors.txt
deleted file mode 100644
index bc7f41ad0c7..00000000000
--- a/tests/baselines/reference/multiExtendsSplitInterfaces1.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/compiler/multiExtendsSplitInterfaces1.ts(1,1): error TS2304: Cannot find name 'self'.
-
-
-==== tests/cases/compiler/multiExtendsSplitInterfaces1.ts (1 errors) ====
-    self.cancelAnimationFrame(0);
-    ~~~~
-!!! error TS2304: Cannot find name 'self'.
\ No newline at end of file
diff --git a/tests/baselines/reference/multiExtendsSplitInterfaces1.symbols b/tests/baselines/reference/multiExtendsSplitInterfaces1.symbols
index bd4b4052cf3..c8c04f39ad4 100644
--- a/tests/baselines/reference/multiExtendsSplitInterfaces1.symbols
+++ b/tests/baselines/reference/multiExtendsSplitInterfaces1.symbols
@@ -1,3 +1,6 @@
 === tests/cases/compiler/multiExtendsSplitInterfaces1.ts ===
 self.cancelAnimationFrame(0);
-No type information for this code.
\ No newline at end of file
+>self.cancelAnimationFrame : Symbol(Window.cancelAnimationFrame, Decl(lib.d.ts, --, --))
+>self : Symbol(self, Decl(lib.d.ts, --, --))
+>cancelAnimationFrame : Symbol(Window.cancelAnimationFrame, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/multiExtendsSplitInterfaces1.types b/tests/baselines/reference/multiExtendsSplitInterfaces1.types
index 8465777eeb0..3ebdfffb12e 100644
--- a/tests/baselines/reference/multiExtendsSplitInterfaces1.types
+++ b/tests/baselines/reference/multiExtendsSplitInterfaces1.types
@@ -1,8 +1,8 @@
 === tests/cases/compiler/multiExtendsSplitInterfaces1.ts ===
 self.cancelAnimationFrame(0);
->self.cancelAnimationFrame(0) : any
->self.cancelAnimationFrame : any
->self : any
->cancelAnimationFrame : any
+>self.cancelAnimationFrame(0) : void
+>self.cancelAnimationFrame : (handle: number) => void
+>self : Window
+>cancelAnimationFrame : (handle: number) => void
 >0 : 0
 
diff --git a/tests/baselines/reference/narrowFromAnyWithInstanceof.symbols b/tests/baselines/reference/narrowFromAnyWithInstanceof.symbols
index f0757b7aa33..6203a2d096b 100644
--- a/tests/baselines/reference/narrowFromAnyWithInstanceof.symbols
+++ b/tests/baselines/reference/narrowFromAnyWithInstanceof.symbols
@@ -45,7 +45,7 @@ if (x instanceof Error) { // 'any' is narrowed to types other than 'Function'/'O
 
 if (x instanceof Date) {
 >x : Symbol(x, Decl(narrowFromAnyWithInstanceof.ts, 0, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     x.getDate();
 >x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
diff --git a/tests/baselines/reference/narrowFromAnyWithTypePredicate.symbols b/tests/baselines/reference/narrowFromAnyWithTypePredicate.symbols
index dd7750a9c07..ac25fde581b 100644
--- a/tests/baselines/reference/narrowFromAnyWithTypePredicate.symbols
+++ b/tests/baselines/reference/narrowFromAnyWithTypePredicate.symbols
@@ -29,7 +29,7 @@ declare function isDate(x): x is Date;
 >isDate : Symbol(isDate, Decl(narrowFromAnyWithTypePredicate.ts, 4, 40))
 >x : Symbol(x, Decl(narrowFromAnyWithTypePredicate.ts, 5, 24))
 >x : Symbol(x, Decl(narrowFromAnyWithTypePredicate.ts, 5, 24))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 
 if (isFunction(x)) { // 'any' is not narrowed when target type is 'Function'
diff --git a/tests/baselines/reference/newNamesInGlobalAugmentations1.symbols b/tests/baselines/reference/newNamesInGlobalAugmentations1.symbols
index ddb09c31403..39fa693a146 100644
--- a/tests/baselines/reference/newNamesInGlobalAugmentations1.symbols
+++ b/tests/baselines/reference/newNamesInGlobalAugmentations1.symbols
@@ -12,7 +12,7 @@ declare global {
 >global : Symbol(global, Decl(f1.d.ts, 4, 1))
 
     interface SymbolConstructor {
->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(f1.d.ts, 5, 16))
+>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(f1.d.ts, 5, 16))
 
         observable: symbol;
 >observable : Symbol(SymbolConstructor.observable, Decl(f1.d.ts, 6, 33))
@@ -35,7 +35,7 @@ declare global {
 === tests/cases/compiler/main.ts ===
 Symbol.observable;
 >Symbol.observable : Symbol(SymbolConstructor.observable, Decl(f1.d.ts, 6, 33))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >observable : Symbol(SymbolConstructor.observable, Decl(f1.d.ts, 6, 33))
 
 new Cls().x
diff --git a/tests/baselines/reference/newOperator.symbols b/tests/baselines/reference/newOperator.symbols
index c5bfc77f5cb..de20d11ddf2 100644
--- a/tests/baselines/reference/newOperator.symbols
+++ b/tests/baselines/reference/newOperator.symbols
@@ -9,11 +9,11 @@ var i = new ifc();
 // Parens are optional
 var x = new Date;
 >x : Symbol(x, Decl(newOperator.ts, 5, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var y = new Date();
 >y : Symbol(y, Decl(newOperator.ts, 6, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Target is not a class or var, good error
 var t1 = new 53();
@@ -27,7 +27,7 @@ new string;
 // Use in LHS of expression?
 (new Date()).toString();
 >(new Date()).toString : Symbol(Date.toString, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >toString : Symbol(Date.toString, Decl(lib.d.ts, --, --))
 
 // Various spacing
@@ -51,7 +51,7 @@ var f = new q();
 // not legal
 var t5 = new new Date;
 >t5 : Symbol(t5, Decl(newOperator.ts, 30, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Can be an expression
 new String;
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
index 45115b278ad..38597019c4f 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
@@ -1,6 +1,6 @@
 === tests/cases/compiler/noCollisionThisExpressionAndLocalVarInLambda.ts ===
 declare function alert(message?: any): void;
->alert : Symbol(alert, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
 >message : Symbol(message, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 23))
 
 var x = {
@@ -19,11 +19,11 @@ var x = {
     }
 }
 alert(x.doStuff(x => alert(x)));
->alert : Symbol(alert, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
 >x.doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 3))
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
->alert : Symbol(alert, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
 
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.types b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.types
index a0a9a25c516..88caf899acd 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.types
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/noCollisionThisExpressionAndLocalVarInLambda.ts ===
 declare function alert(message?: any): void;
->alert : (message?: any) => void
+>alert : { (message?: any): void; (message?: any): void; }
 >message : any
 
 var x = {
@@ -25,7 +25,7 @@ var x = {
 }
 alert(x.doStuff(x => alert(x)));
 >alert(x.doStuff(x => alert(x))) : void
->alert : (message?: any) => void
+>alert : { (message?: any): void; (message?: any): void; }
 >x.doStuff(x => alert(x)) : () => any
 >x.doStuff : (callback: any) => () => any
 >x : { doStuff: (callback: any) => () => any; }
@@ -33,6 +33,6 @@ alert(x.doStuff(x => alert(x)));
 >x => alert(x) : (x: any) => void
 >x : any
 >alert(x) : void
->alert : (message?: any) => void
+>alert : { (message?: any): void; (message?: any): void; }
 >x : any
 
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
index b039eb555f7..3717c07625b 100644
--- a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
+++ b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
@@ -10,7 +10,7 @@ async function test(isError: boolean = false) {
     }
     let x = await Promise.resolve("The test is passed without an error.");
 >x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 4, 7))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync2.symbols b/tests/baselines/reference/noImplicitReturnsInAsync2.symbols
index 8bea8772e89..097b5ef7cec 100644
--- a/tests/baselines/reference/noImplicitReturnsInAsync2.symbols
+++ b/tests/baselines/reference/noImplicitReturnsInAsync2.symbols
@@ -28,7 +28,7 @@ async function test4(isError: boolean = true) {
 async function test5(isError: boolean = true): Promise<any> { //should not be error
 >test5 : Symbol(test5, Decl(noImplicitReturnsInAsync2.ts, 12, 1))
 >isError : Symbol(isError, Decl(noImplicitReturnsInAsync2.ts, 15, 21))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     if (isError === true) {
 >isError : Symbol(isError, Decl(noImplicitReturnsInAsync2.ts, 15, 21))
@@ -43,7 +43,7 @@ async function test5(isError: boolean = true): Promise<any> { //should not be er
 async function test6(isError: boolean = true): Promise<number> { 
 >test6 : Symbol(test6, Decl(noImplicitReturnsInAsync2.ts, 19, 1))
 >isError : Symbol(isError, Decl(noImplicitReturnsInAsync2.ts, 23, 21))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     if (isError === true) {
 >isError : Symbol(isError, Decl(noImplicitReturnsInAsync2.ts, 23, 21))
diff --git a/tests/baselines/reference/nullAssignableToEveryType.symbols b/tests/baselines/reference/nullAssignableToEveryType.symbols
index 969686563a3..9212d6df499 100644
--- a/tests/baselines/reference/nullAssignableToEveryType.symbols
+++ b/tests/baselines/reference/nullAssignableToEveryType.symbols
@@ -38,7 +38,7 @@ var d: boolean = null;
 
 var e: Date = null;
 >e : Symbol(e, Decl(nullAssignableToEveryType.ts, 15, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f: any = null;
 >f : Symbol(f, Decl(nullAssignableToEveryType.ts, 16, 3))
@@ -100,7 +100,7 @@ function foo<T, U, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(nullAssignableToEveryType.ts, 32, 13))
 >U : Symbol(U, Decl(nullAssignableToEveryType.ts, 32, 15))
 >V : Symbol(V, Decl(nullAssignableToEveryType.ts, 32, 18))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(nullAssignableToEveryType.ts, 32, 35))
 >T : Symbol(T, Decl(nullAssignableToEveryType.ts, 32, 13))
 >y : Symbol(y, Decl(nullAssignableToEveryType.ts, 32, 40))
diff --git a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
index 3d4fb84145e..536bf6b2ec9 100644
--- a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
+++ b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
@@ -39,11 +39,11 @@ var r3 = true ? null : true;
 
 var r4 = true ? new Date() : null;
 >r4 : Symbol(r4, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 18, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 19, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r4 = true ? null : new Date();
 >r4 : Symbol(r4, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 18, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 19, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r5 = true ? /1/ : null;
 >r5 : Symbol(r5, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 21, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 22, 3))
diff --git a/tests/baselines/reference/numericIndexerConstraint5.symbols b/tests/baselines/reference/numericIndexerConstraint5.symbols
index ff4183c9e9a..6cfc8db1e17 100644
--- a/tests/baselines/reference/numericIndexerConstraint5.symbols
+++ b/tests/baselines/reference/numericIndexerConstraint5.symbols
@@ -2,7 +2,7 @@
 var x = { name: "x", 0: new Date() };
 >x : Symbol(x, Decl(numericIndexerConstraint5.ts, 0, 3))
 >name : Symbol(name, Decl(numericIndexerConstraint5.ts, 0, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var z: { [name: number]: string } = x;
 >z : Symbol(z, Decl(numericIndexerConstraint5.ts, 1, 3))
diff --git a/tests/baselines/reference/numericIndexerTyping1.symbols b/tests/baselines/reference/numericIndexerTyping1.symbols
index cf894348af4..110eff563fb 100644
--- a/tests/baselines/reference/numericIndexerTyping1.symbols
+++ b/tests/baselines/reference/numericIndexerTyping1.symbols
@@ -4,7 +4,7 @@ interface I {
 
     [x: string]: Date;
 >x : Symbol(x, Decl(numericIndexerTyping1.ts, 1, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 extends I {
diff --git a/tests/baselines/reference/numericIndexerTyping2.symbols b/tests/baselines/reference/numericIndexerTyping2.symbols
index 1f1aa7edc99..c5e4c3b4c98 100644
--- a/tests/baselines/reference/numericIndexerTyping2.symbols
+++ b/tests/baselines/reference/numericIndexerTyping2.symbols
@@ -4,7 +4,7 @@ class I {
 
     [x: string]: Date
 >x : Symbol(x, Decl(numericIndexerTyping2.ts, 1, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class I2 extends I {
diff --git a/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.symbols b/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.symbols
index a7223a8df30..76bbea5a195 100644
--- a/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.symbols
+++ b/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.symbols
@@ -1,11 +1,11 @@
 === tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts ===
 1..toString();
->1..toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>1..toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 1.0.toString();
->1.0.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>1.0.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 1.toString();
 >toString : Symbol(toString, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 8, 14))
@@ -18,9 +18,9 @@ var i: number = 1;
 
 var test1 = i.toString();  
 >test1 : Symbol(test1, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 7, 3))
->i.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>i.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 6, 3))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test2 = 2.toString();
 >test2 : Symbol(test2, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 8, 3))
@@ -28,35 +28,35 @@ var test2 = 2.toString();
 
 var test3 = 3 .toString();
 >test3 : Symbol(test3, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 9, 3))
->3 .toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>3 .toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test4 = 3    .toString();
 >test4 : Symbol(test4, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 10, 3))
->3    .toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>3    .toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test5 = 3	.toString(); 
 >test5 : Symbol(test5, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 11, 3))
->3	.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>3	.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test6 = 3.['toString']();
 >test6 : Symbol(test6, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 12, 3))
->'toString' : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>'toString' : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test7 = 3
 >test7 : Symbol(test7, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 13, 3))
->3.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>3.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 .toString();
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test8 = new Number(4).toString();
 >test8 : Symbol(test8, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 15, 3))
->new Number(4).toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>new Number(4).toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
 
 var test9 = 3. + 3.
 >test9 : Symbol(test9, Decl(numericLiteralsWithTrailingDecimalPoints01.ts, 16, 3))
diff --git a/tests/baselines/reference/objectLiteralGettersAndSetters.symbols b/tests/baselines/reference/objectLiteralGettersAndSetters.symbols
index 5a4250f9c82..72f74f4bd2b 100644
--- a/tests/baselines/reference/objectLiteralGettersAndSetters.symbols
+++ b/tests/baselines/reference/objectLiteralGettersAndSetters.symbols
@@ -144,11 +144,11 @@ var sameType3 = { get x(): any { return undefined; }, set x(n: typeof anyVar) {
 var sameType4 = { get x(): Date { return undefined; }, set x(n: Date) { } };
 >sameType4 : Symbol(sameType4, Decl(objectLiteralGettersAndSetters.ts, 37, 3))
 >x : Symbol(x, Decl(objectLiteralGettersAndSetters.ts, 37, 17), Decl(objectLiteralGettersAndSetters.ts, 37, 54))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(objectLiteralGettersAndSetters.ts, 37, 17), Decl(objectLiteralGettersAndSetters.ts, 37, 54))
 >n : Symbol(n, Decl(objectLiteralGettersAndSetters.ts, 37, 61))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Type of unannotated get accessor return type is the type annotation of the set accessor param
 var setParamType1 = {
diff --git a/tests/baselines/reference/objectRestForOf.symbols b/tests/baselines/reference/objectRestForOf.symbols
index 2d5d6a2bb2d..2a384ce0923 100644
--- a/tests/baselines/reference/objectRestForOf.symbols
+++ b/tests/baselines/reference/objectRestForOf.symbols
@@ -32,9 +32,9 @@ for ({ x: xx, ...rrestOff } of array ) {
 }
 for (const norest of array.map(a => ({ ...a, x: 'a string' }))) {
 >norest : Symbol(norest, Decl(objectRestForOf.ts, 9, 10))
->array.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>array.map : Symbol(Array.map, Decl(lib.es6.d.ts, --, --))
 >array : Symbol(array, Decl(objectRestForOf.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(objectRestForOf.ts, 9, 31))
 >a : Symbol(a, Decl(objectRestForOf.ts, 9, 31))
 >x : Symbol(x, Decl(objectRestForOf.ts, 9, 44))
diff --git a/tests/baselines/reference/objectTypeHidingMembersOfExtendedObject.symbols b/tests/baselines/reference/objectTypeHidingMembersOfExtendedObject.symbols
index 8cc5c7bf3d6..19de6a04838 100644
--- a/tests/baselines/reference/objectTypeHidingMembersOfExtendedObject.symbols
+++ b/tests/baselines/reference/objectTypeHidingMembersOfExtendedObject.symbols
@@ -15,7 +15,7 @@ class B extends A {
 }
 
 interface Object {
->Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeHidingMembersOfExtendedObject.ts, 6, 1))
+>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(objectTypeHidingMembersOfExtendedObject.ts, 6, 1))
 
     data: A;
 >data : Symbol(Object.data, Decl(objectTypeHidingMembersOfExtendedObject.ts, 8, 18))
@@ -23,7 +23,7 @@ interface Object {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(objectTypeHidingMembersOfExtendedObject.ts, 10, 5))
->Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeHidingMembersOfExtendedObject.ts, 6, 1))
+>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(objectTypeHidingMembersOfExtendedObject.ts, 6, 1))
 }
 
 class C {
diff --git a/tests/baselines/reference/objectTypeWithStringIndexerHidingObjectIndexer.symbols b/tests/baselines/reference/objectTypeWithStringIndexerHidingObjectIndexer.symbols
index 19df4ab30fa..23513514cee 100644
--- a/tests/baselines/reference/objectTypeWithStringIndexerHidingObjectIndexer.symbols
+++ b/tests/baselines/reference/objectTypeWithStringIndexerHidingObjectIndexer.symbols
@@ -3,11 +3,11 @@
 // no errors expected below 
 
 interface Object {
->Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeWithStringIndexerHidingObjectIndexer.ts, 0, 0))
+>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(objectTypeWithStringIndexerHidingObjectIndexer.ts, 0, 0))
 
     [x: string]: Object;
 >x : Symbol(x, Decl(objectTypeWithStringIndexerHidingObjectIndexer.ts, 4, 5))
->Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeWithStringIndexerHidingObjectIndexer.ts, 0, 0))
+>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(objectTypeWithStringIndexerHidingObjectIndexer.ts, 0, 0))
 }
 var o = {};
 >o : Symbol(o, Decl(objectTypeWithStringIndexerHidingObjectIndexer.ts, 6, 3))
diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
index 37564117077..c847291d7b3 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
+++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
@@ -14,13 +14,13 @@ class C {
     "1.": string;
     "1..": boolean;
     "1.0": Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": RegExp;
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1": Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var c: C;
@@ -120,13 +120,13 @@ interface I {
     "1.": string;
     "1..": boolean;
     "1.0": Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": RegExp;
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1": Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var i: I;
@@ -226,13 +226,13 @@ var a: {
     "1.": string;
     "1..": boolean;
     "1.0": Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": RegExp;
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1": Date;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var r1 = a['0.1'];
@@ -328,11 +328,11 @@ var b = {
     "1.": "",
     "1..": true,
     "1.0": new Date(),
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": /123/,
     "-1": Date
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
 
diff --git a/tests/baselines/reference/objectTypesIdentity2.symbols b/tests/baselines/reference/objectTypesIdentity2.symbols
index eb04eaf03c7..b72bd836530 100644
--- a/tests/baselines/reference/objectTypesIdentity2.symbols
+++ b/tests/baselines/reference/objectTypesIdentity2.symbols
@@ -29,7 +29,7 @@ interface I {
 
     foo: Date;
 >foo : Symbol(I.foo, Decl(objectTypesIdentity2.ts, 14, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a: { foo: RegExp; }
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
index fb01ef775c4..3c4e89482af 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
@@ -51,7 +51,7 @@ var a: { foo(x: Date): string }
 >a : Symbol(a, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 8))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b = { foo(x: RegExp) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 3))
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
index 64677b63c5f..3f54560782b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
@@ -37,7 +37,7 @@ interface I2<T> {
 var a: { new(x: Date): string }
 >a : Symbol(a, Decl(objectTypesIdentityWithConstructSignatures2.ts, 18, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 18, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 3))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
index 7d017936a04..5e0af45f907 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
@@ -9,7 +9,7 @@ class A {
     foo<T extends Date>(x: T): string { return null; }
 >foo : Symbol(A.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 4, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 8))
 }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.symbols
index e37b606be59..ee55a60f59c 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.symbols
@@ -11,7 +11,7 @@ class A {
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.ts, 5, 8))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.ts, 5, 20))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.ts, 5, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.ts, 5, 37))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.ts, 5, 8))
 >y : Symbol(y, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.ts, 5, 42))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
index a3f4f8038a0..6a3b4c81bdf 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
@@ -41,7 +41,7 @@ interface I<T> {
 >foo : Symbol(I.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 16, 16))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 17, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
index d90a4b1d545..f44a4f08d8c 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
@@ -9,7 +9,7 @@ class A {
     foo<T extends Date>(x: T): string { return null; }
 >foo : Symbol(A.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 4, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 8))
 }
@@ -17,7 +17,7 @@ class A {
 class B<T extends Date> {
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): number { return null; }
 >foo : Symbol(B.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 8, 25))
@@ -28,7 +28,7 @@ class B<T extends Date> {
 class C<T extends Date> {
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 12, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): boolean { return null; }
 >foo : Symbol(C.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 12, 25))
@@ -39,13 +39,13 @@ class C<T extends Date> {
 interface I<T extends Date> {
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): Date;
 >foo : Symbol(I.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 17, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
@@ -54,7 +54,7 @@ interface I2 {
     foo<T extends Date>(x: T): RegExp;
 >foo : Symbol(I2.foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 20, 14))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 8))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
@@ -64,7 +64,7 @@ var a: { foo<T extends Date>(x: T): T }
 >a : Symbol(a, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 29))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13))
@@ -73,7 +73,7 @@ var b = { foo<T extends Date>(x: T) { return null; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 30))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14))
 
@@ -95,13 +95,13 @@ function foo1b(x: B<Date>);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B<Date>); // error
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: any) { }
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27))
@@ -111,13 +111,13 @@ function foo1c(x: C<Date>);
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: C<Date>); // error
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: any) { }
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27))
@@ -127,13 +127,13 @@ function foo2(x: I<Date>);
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: I<Date>); // error
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: any) { }
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26))
@@ -176,7 +176,7 @@ function foo5(x: B<Date>); // ok
 >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo5(x: any) { }
 >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 26))
@@ -191,7 +191,7 @@ function foo5b(x: C<Date>); // ok
 >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo5b(x: any) { }
 >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 27))
@@ -206,7 +206,7 @@ function foo6(x: I<Date>); // ok
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo6(x: any) { }
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 26))
@@ -230,13 +230,13 @@ function foo8(x: B<Date>);
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: I<Date>); // ok
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26))
@@ -246,13 +246,13 @@ function foo9(x: B<Date>);
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: C<Date>); // ok
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 14))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: any) { }
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26))
@@ -262,7 +262,7 @@ function foo10(x: B<Date>);
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 76, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo10(x: typeof a); // ok
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 76, 28))
@@ -277,7 +277,7 @@ function foo11(x: B<Date>);
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 80, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo11(x: typeof b); // ok
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 80, 28))
@@ -292,13 +292,13 @@ function foo12(x: I<Date>);
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<Date>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27))
@@ -313,7 +313,7 @@ function foo12b(x: C<Date>); // ok
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 16))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12b(x: any) { }
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 28))
@@ -323,7 +323,7 @@ function foo13(x: I<Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 92, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 92, 28))
@@ -338,7 +338,7 @@ function foo14(x: I<Date>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 96, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 96, 28))
@@ -358,7 +358,7 @@ function foo15(x: C<Date>); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: any) { }
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 27))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
index 748c945d8d0..75d81b820fb 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
@@ -211,7 +211,7 @@ function foo6(x: I<string, number, boolean, Date>); // ok
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 57, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 51))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo6(x: any) { }
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 57, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 51))
@@ -240,7 +240,7 @@ function foo8(x: I<string, string, boolean, Date>); // error
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 63, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 65, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 51))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 63, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 65, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 51))
@@ -294,14 +294,14 @@ function foo12(x: I<B<string, number>, number, Date, string>);
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 4, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<B<string, number>, number, Date>); // error
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 79, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 62), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 54))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 8, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 4, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 79, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 62), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 54))
@@ -325,9 +325,9 @@ function foo13(x: I<string, Date, RegExp, Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 87, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 49), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 90, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 87, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 49), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 90, 28))
@@ -342,7 +342,7 @@ function foo14(x: I<string, Date, RegExp, boolean>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 91, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 94, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols
index a69ddbe5647..61dccbcbfde 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols
@@ -85,7 +85,7 @@ function foo13(x: I<boolean, string, number, Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 23, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 26, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 23, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 26, 28))
@@ -100,7 +100,7 @@ function foo14(x: I<boolean, string, number, Date>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 27, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 30, 22))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: I2); // error
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 27, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 30, 22))
@@ -129,7 +129,7 @@ function foo15(x: I<boolean, string, number, Date>);
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 38, 22))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: I2); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 38, 22))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
index 418ed27a99d..308bce89f50 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
@@ -28,7 +28,7 @@ interface I<T> {
     new(x: T): Date;
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 13, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
index 23702ebab68..55b2a084228 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
@@ -6,7 +6,7 @@
 class B<T extends Date> {
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 4, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x: T) { return null; }
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 5, 16))
@@ -16,7 +16,7 @@ class B<T extends Date> {
 class C<T extends Date> {
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x: T) { return null; }
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 9, 16))
@@ -26,12 +26,12 @@ class C<T extends Date> {
 interface I<T extends Date> {
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     new(x: T): Date;
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 13, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
@@ -39,7 +39,7 @@ interface I2 {
 
     new<T extends Date>(x: T): RegExp;
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 8))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
@@ -48,7 +48,7 @@ interface I2 {
 var a: { new<T extends Date>(x: T): T }
 >a : Symbol(a, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 3))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 29))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13))
@@ -57,7 +57,7 @@ var b = { new<T extends Date>(x: T) { return null; } }; // not a construct signa
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 3))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 30))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14))
 
@@ -65,13 +65,13 @@ function foo1b(x: B<Date>);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B<Date>); // error
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: any) { }
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27))
@@ -81,13 +81,13 @@ function foo1c(x: C<Date>);
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: C<Date>); // error
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: any) { }
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27))
@@ -97,13 +97,13 @@ function foo2(x: I<Date>);
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: I<Date>); // error
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: any) { }
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26))
@@ -141,13 +141,13 @@ function foo8(x: B<Date>);
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: I<Date>); // ok
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26))
@@ -157,13 +157,13 @@ function foo9(x: B<Date>);
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: C<Date>); // error since types are structurally equal
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 14))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: any) { }
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26))
@@ -173,7 +173,7 @@ function foo10(x: B<Date>);
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 52, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo10(x: typeof a); // ok
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 52, 28))
@@ -188,7 +188,7 @@ function foo11(x: B<Date>);
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 56, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo11(x: typeof b); // ok
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 56, 28))
@@ -203,13 +203,13 @@ function foo12(x: I<Date>);
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<Date>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27))
@@ -224,7 +224,7 @@ function foo12b(x: C<Date>); // ok
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 16))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12b(x: any) { }
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 28))
@@ -234,7 +234,7 @@ function foo13(x: I<Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 68, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 68, 28))
@@ -249,7 +249,7 @@ function foo14(x: I<Date>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 72, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 72, 28))
@@ -269,7 +269,7 @@ function foo15(x: C<Date>); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 73, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 75, 22), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: any) { }
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 73, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 75, 22), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 27))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
index e03c24b2ce5..605049ca015 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
@@ -159,7 +159,7 @@ function foo8(x: I<string, string, boolean, Date>); // BUG 832086
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 39, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 41, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 51))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 39, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 41, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 51))
@@ -213,14 +213,14 @@ function foo12(x: I<B<string, number>, number, Date, string>);
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<B<string, number>, number, Date>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 62), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 54))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 4, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 62), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 54))
@@ -244,9 +244,9 @@ function foo13(x: I<string, Date, RegExp, Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 63, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 49), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 66, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 63, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 49), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 66, 28))
@@ -261,7 +261,7 @@ function foo14(x: I<string, Date, RegExp, boolean>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 67, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 52), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 70, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
diff --git a/tests/baselines/reference/overloadOnGenericArity.symbols b/tests/baselines/reference/overloadOnGenericArity.symbols
index a50a788b4e8..3a56861cb7f 100644
--- a/tests/baselines/reference/overloadOnGenericArity.symbols
+++ b/tests/baselines/reference/overloadOnGenericArity.symbols
@@ -10,7 +10,7 @@ interface Test {
     then(p: string): Date; // Error: Overloads cannot differ only by return type
 >then : Symbol(Test.then, Decl(overloadOnGenericArity.ts, 0, 16), Decl(overloadOnGenericArity.ts, 1, 31))
 >p : Symbol(p, Decl(overloadOnGenericArity.ts, 2, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
   
 
diff --git a/tests/baselines/reference/overloadResolution.symbols b/tests/baselines/reference/overloadResolution.symbols
index a9e150c1a23..096d6991644 100644
--- a/tests/baselines/reference/overloadResolution.symbols
+++ b/tests/baselines/reference/overloadResolution.symbols
@@ -77,12 +77,12 @@ function fn2() { return undefined; }
 var d = fn2<Date>(0, undefined);
 >d : Symbol(d, Decl(overloadResolution.ts, 33, 3), Decl(overloadResolution.ts, 34, 3))
 >fn2 : Symbol(fn2, Decl(overloadResolution.ts, 26, 8), Decl(overloadResolution.ts, 29, 43), Decl(overloadResolution.ts, 30, 36))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var d: Date;
 >d : Symbol(d, Decl(overloadResolution.ts, 33, 3), Decl(overloadResolution.ts, 34, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic and non - generic overload where generic overload is the only candidate when called without type arguments
 var s = fn2(0, '');
@@ -92,7 +92,7 @@ var s = fn2(0, '');
 // Generic and non - generic overload where non - generic overload is the only candidate when called with type arguments
 fn2<Date>('', 0); // Error
 >fn2 : Symbol(fn2, Decl(overloadResolution.ts, 26, 8), Decl(overloadResolution.ts, 29, 43), Decl(overloadResolution.ts, 30, 36))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic and non - generic overload where non - generic overload is the only candidate when called without type arguments
 fn2('', 0); // OK
@@ -214,7 +214,7 @@ fn4('', null);
 // Generic overloads with constraints called with type arguments that do not satisfy the constraints
 fn4<boolean, Date>(null, null); // Error
 >fn4 : Symbol(fn4, Decl(overloadResolution.ts, 62, 38), Decl(overloadResolution.ts, 65, 61), Decl(overloadResolution.ts, 66, 61))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
 fn4(true, null); // Error
diff --git a/tests/baselines/reference/overloadResolutionClassConstructors.symbols b/tests/baselines/reference/overloadResolutionClassConstructors.symbols
index 469529e186d..193ca469bab 100644
--- a/tests/baselines/reference/overloadResolutionClassConstructors.symbols
+++ b/tests/baselines/reference/overloadResolutionClassConstructors.symbols
@@ -72,7 +72,7 @@ class fn2<T> {
 var d = new fn2<Date>(0, undefined);
 >d : Symbol(d, Decl(overloadResolutionClassConstructors.ts, 35, 3))
 >fn2 : Symbol(fn2, Decl(overloadResolutionClassConstructors.ts, 26, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 // Generic and non - generic overload where generic overload is the only candidate when called without type arguments
@@ -83,7 +83,7 @@ var s = new fn2(0, '');
 // Generic and non - generic overload where non - generic overload is the only candidate when called with type arguments
 new fn2<Date>('', 0); // OK
 >fn2 : Symbol(fn2, Decl(overloadResolutionClassConstructors.ts, 26, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic and non - generic overload where non - generic overload is the only candidate when called without type arguments
 new fn2('', 0); // OK
@@ -184,7 +184,7 @@ new fn4('', null);
 // Generic overloads with constraints called with type arguments that do not satisfy the constraints
 new fn4<boolean, Date>(null, null); // Error
 >fn4 : Symbol(fn4, Decl(overloadResolutionClassConstructors.ts, 64, 42))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
 new fn4(true, null); // Error
diff --git a/tests/baselines/reference/overloadResolutionConstructors.symbols b/tests/baselines/reference/overloadResolutionConstructors.symbols
index 1703e4060c3..0c9f9b413aa 100644
--- a/tests/baselines/reference/overloadResolutionConstructors.symbols
+++ b/tests/baselines/reference/overloadResolutionConstructors.symbols
@@ -78,12 +78,12 @@ var fn2: fn2;
 var d = new fn2<Date>(0, undefined);
 >d : Symbol(d, Decl(overloadResolutionConstructors.ts, 35, 3), Decl(overloadResolutionConstructors.ts, 36, 3))
 >fn2 : Symbol(fn2, Decl(overloadResolutionConstructors.ts, 26, 12), Decl(overloadResolutionConstructors.ts, 33, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var d: Date;
 >d : Symbol(d, Decl(overloadResolutionConstructors.ts, 35, 3), Decl(overloadResolutionConstructors.ts, 36, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic and non - generic overload where generic overload is the only candidate when called without type arguments
 var s = new fn2(0, '');
@@ -93,7 +93,7 @@ var s = new fn2(0, '');
 // Generic and non - generic overload where non - generic overload is the only candidate when called with type arguments
 new fn2<Date>('', 0); // Error
 >fn2 : Symbol(fn2, Decl(overloadResolutionConstructors.ts, 26, 12), Decl(overloadResolutionConstructors.ts, 33, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic and non - generic overload where non - generic overload is the only candidate when called without type arguments
 new fn2('', 0); // OK
@@ -218,7 +218,7 @@ new fn4('', null);
 // Generic overloads with constraints called with type arguments that do not satisfy the constraints
 new fn4<boolean, Date>(null, null); // Error
 >fn4 : Symbol(fn4, Decl(overloadResolutionConstructors.ts, 66, 42), Decl(overloadResolutionConstructors.ts, 73, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
 new fn4(true, null); // Error
diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
index 25ef572e230..b74efeb1f53 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
@@ -8,7 +8,7 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T;
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17))
 >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 5, 20))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 5, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 5, 56))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 5, 17))
@@ -21,7 +21,7 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) =>
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17))
 >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 6, 20))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 6, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 56))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17))
@@ -38,7 +38,7 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 5, 77), Decl(parenthesizedContexualTyping3.ts, 6, 93))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17))
 >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 7, 20))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 7, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 56))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17))
diff --git a/tests/baselines/reference/parserArgumentList1.errors.txt b/tests/baselines/reference/parserArgumentList1.errors.txt
index f01dfb531f0..81eaadefa69 100644
--- a/tests/baselines/reference/parserArgumentList1.errors.txt
+++ b/tests/baselines/reference/parserArgumentList1.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/conformance/parser/ecmascript5/parserArgumentList1.ts(1,35): error TS2304: Cannot find name 'HTMLElement'.
 tests/cases/conformance/parser/ecmascript5/parserArgumentList1.ts(2,42): error TS2304: Cannot find name '_classNameRegexp'.
 
 
-==== tests/cases/conformance/parser/ecmascript5/parserArgumentList1.ts (2 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/parserArgumentList1.ts (1 errors) ====
     export function removeClass (node:HTMLElement, className:string) {
-                                      ~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'HTMLElement'.
     	node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {
     	                                        ~~~~~~~~~~~~~~~~
 !!! error TS2304: Cannot find name '_classNameRegexp'.
diff --git a/tests/baselines/reference/parserArgumentList1.symbols b/tests/baselines/reference/parserArgumentList1.symbols
index b26819eb2df..2b6bd9ae222 100644
--- a/tests/baselines/reference/parserArgumentList1.symbols
+++ b/tests/baselines/reference/parserArgumentList1.symbols
@@ -2,11 +2,18 @@
 export function removeClass (node:HTMLElement, className:string) {
 >removeClass : Symbol(removeClass, Decl(parserArgumentList1.ts, 0, 0))
 >node : Symbol(node, Decl(parserArgumentList1.ts, 0, 29))
+>HTMLElement : Symbol(HTMLElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >className : Symbol(className, Decl(parserArgumentList1.ts, 0, 46))
 
 	node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {
+>node.className : Symbol(Element.className, Decl(lib.d.ts, --, --))
 >node : Symbol(node, Decl(parserArgumentList1.ts, 0, 29))
+>className : Symbol(Element.className, Decl(lib.d.ts, --, --))
+>node.className.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>node.className : Symbol(Element.className, Decl(lib.d.ts, --, --))
 >node : Symbol(node, Decl(parserArgumentList1.ts, 0, 29))
+>className : Symbol(Element.className, Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >className : Symbol(className, Decl(parserArgumentList1.ts, 0, 46))
 >everything : Symbol(everything, Decl(parserArgumentList1.ts, 1, 80))
 >leftDelimiter : Symbol(leftDelimiter, Decl(parserArgumentList1.ts, 1, 91))
diff --git a/tests/baselines/reference/parserArgumentList1.types b/tests/baselines/reference/parserArgumentList1.types
index e3e386d689f..ddf00ee8750 100644
--- a/tests/baselines/reference/parserArgumentList1.types
+++ b/tests/baselines/reference/parserArgumentList1.types
@@ -1,26 +1,26 @@
 === tests/cases/conformance/parser/ecmascript5/parserArgumentList1.ts ===
 export function removeClass (node:HTMLElement, className:string) {
->removeClass : (node: any, className: string) => void
->node : any
->HTMLElement : No type information available!
+>removeClass : (node: HTMLElement, className: string) => void
+>node : HTMLElement
+>HTMLElement : HTMLElement
 >className : string
 
 	node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {
->node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';	}) : any
->node.className : any
->node : any
->className : any
->node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';	}) : any
->node.className.replace : any
->node.className : any
->node : any
->className : any
->replace : any
+>node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';	}) : string
+>node.className : string
+>node : HTMLElement
+>className : string
+>node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';	}) : string
+>node.className.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>node.className : string
+>node : HTMLElement
+>className : string
+>replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
 >_classNameRegexp(className) : any
 >_classNameRegexp : any
 >className : string
->function (everything, leftDelimiter, name, rightDelimiter) {		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';	} : (everything: any, leftDelimiter: any, name: any, rightDelimiter: any) => " " | ""
->everything : any
+>function (everything, leftDelimiter, name, rightDelimiter) {		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';	} : (everything: string, leftDelimiter: any, name: any, rightDelimiter: any) => " " | ""
+>everything : string
 >leftDelimiter : any
 >name : any
 >rightDelimiter : any
diff --git a/tests/baselines/reference/parserConstructorAmbiguity1.symbols b/tests/baselines/reference/parserConstructorAmbiguity1.symbols
index b57d027542a..60044726e9f 100644
--- a/tests/baselines/reference/parserConstructorAmbiguity1.symbols
+++ b/tests/baselines/reference/parserConstructorAmbiguity1.symbols
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/Generics/parserConstructorAmbiguity1.ts ===
 new Date<A;
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/parserConstructorAmbiguity2.symbols b/tests/baselines/reference/parserConstructorAmbiguity2.symbols
index 1dee1297cf9..d53f5628106 100644
--- a/tests/baselines/reference/parserConstructorAmbiguity2.symbols
+++ b/tests/baselines/reference/parserConstructorAmbiguity2.symbols
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/Generics/parserConstructorAmbiguity2.ts ===
 new Date<A
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/parserConstructorAmbiguity3.symbols b/tests/baselines/reference/parserConstructorAmbiguity3.symbols
index 914a5367f7e..9c76818ebf2 100644
--- a/tests/baselines/reference/parserConstructorAmbiguity3.symbols
+++ b/tests/baselines/reference/parserConstructorAmbiguity3.symbols
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/Generics/parserConstructorAmbiguity3.ts ===
 new Date<A>
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/parserConstructorAmbiguity4.symbols b/tests/baselines/reference/parserConstructorAmbiguity4.symbols
index d080b257e5a..69449eb070a 100644
--- a/tests/baselines/reference/parserConstructorAmbiguity4.symbols
+++ b/tests/baselines/reference/parserConstructorAmbiguity4.symbols
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/Generics/parserConstructorAmbiguity4.ts ===
 new Date<A ? B : C
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/parserInExpression1.errors.txt b/tests/baselines/reference/parserInExpression1.errors.txt
deleted file mode 100644
index d0f9778b294..00000000000
--- a/tests/baselines/reference/parserInExpression1.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/conformance/parser/ecmascript5/parserInExpression1.ts(1,1): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/conformance/parser/ecmascript5/parserInExpression1.ts (1 errors) ====
-    console.log("a" in { "a": true });
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserInExpression1.symbols b/tests/baselines/reference/parserInExpression1.symbols
index c351905f2fd..25c37cb3ed2 100644
--- a/tests/baselines/reference/parserInExpression1.symbols
+++ b/tests/baselines/reference/parserInExpression1.symbols
@@ -1,3 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/parserInExpression1.ts ===
 console.log("a" in { "a": true });
-No type information for this code.
\ No newline at end of file
+>console.log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/parserInExpression1.types b/tests/baselines/reference/parserInExpression1.types
index 64612921479..259d148c798 100644
--- a/tests/baselines/reference/parserInExpression1.types
+++ b/tests/baselines/reference/parserInExpression1.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/parser/ecmascript5/parserInExpression1.ts ===
 console.log("a" in { "a": true });
->console.log("a" in { "a": true }) : any
->console.log : any
->console : any
->log : any
+>console.log("a" in { "a": true }) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
 >"a" in { "a": true } : boolean
 >"a" : "a"
 >{ "a": true } : { "a": boolean; }
diff --git a/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.errors.txt b/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.errors.txt
index 36bd5b08e19..f2d01177320 100644
--- a/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.errors.txt
+++ b/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.errors.txt
@@ -1,13 +1,10 @@
 tests/cases/conformance/parser/ecmascript5/parserNoASIOnCallAfterFunctionExpression1.ts(1,9): error TS2554: Expected 0 arguments, but got 1.
-tests/cases/conformance/parser/ecmascript5/parserNoASIOnCallAfterFunctionExpression1.ts(2,7): error TS2304: Cannot find name 'window'.
 
 
-==== tests/cases/conformance/parser/ecmascript5/parserNoASIOnCallAfterFunctionExpression1.ts (2 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/parserNoASIOnCallAfterFunctionExpression1.ts (1 errors) ====
     var x = function () { }
             ~~~~~~~~~~~~~~~
     (<any>window).foo;
     ~~~~~~~~~~~~~
 !!! error TS2554: Expected 0 arguments, but got 1.
-          ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.symbols b/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.symbols
index a8e686cd7e3..b71c25b6b15 100644
--- a/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.symbols
+++ b/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.symbols
@@ -3,4 +3,5 @@ var x = function () { }
 >x : Symbol(x, Decl(parserNoASIOnCallAfterFunctionExpression1.ts, 0, 3))
 
 (<any>window).foo;
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.types b/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.types
index 083eb5f66e4..703107905e6 100644
--- a/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.types
+++ b/tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.types
@@ -7,6 +7,6 @@ var x = function () { }
 
 (<any>window).foo;
 ><any>window : any
->window : any
+>window : Window
 >foo : any
 
diff --git a/tests/baselines/reference/parserNotHexLiteral1.errors.txt b/tests/baselines/reference/parserNotHexLiteral1.errors.txt
deleted file mode 100644
index 7c0cbf6f604..00000000000
--- a/tests/baselines/reference/parserNotHexLiteral1.errors.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-tests/cases/conformance/parser/ecmascript5/RegressionTests/parserNotHexLiteral1.ts(2,1): error TS2304: Cannot find name 'console'.
-tests/cases/conformance/parser/ecmascript5/RegressionTests/parserNotHexLiteral1.ts(5,1): error TS2304: Cannot find name 'console'.
-
-
-==== tests/cases/conformance/parser/ecmascript5/RegressionTests/parserNotHexLiteral1.ts (2 errors) ====
-    var x = {e0: 'cat', x0: 'dog'};
-    console.info (x.x0);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    // tsc dies on this next line with "bug.ts (5,16): Expected ')'"
-    //   tsc seems to be parsing the e0 as a hex constant.
-    console.info (x.e0);
-    ~~~~~~~
-!!! error TS2304: Cannot find name 'console'.
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/parserNotHexLiteral1.symbols b/tests/baselines/reference/parserNotHexLiteral1.symbols
index 3070cd1db7c..f664a95fbf0 100644
--- a/tests/baselines/reference/parserNotHexLiteral1.symbols
+++ b/tests/baselines/reference/parserNotHexLiteral1.symbols
@@ -5,6 +5,9 @@ var x = {e0: 'cat', x0: 'dog'};
 >x0 : Symbol(x0, Decl(parserNotHexLiteral1.ts, 0, 19))
 
 console.info (x.x0);
+>console.info : Symbol(Console.info, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>info : Symbol(Console.info, Decl(lib.d.ts, --, --))
 >x.x0 : Symbol(x0, Decl(parserNotHexLiteral1.ts, 0, 19))
 >x : Symbol(x, Decl(parserNotHexLiteral1.ts, 0, 3))
 >x0 : Symbol(x0, Decl(parserNotHexLiteral1.ts, 0, 19))
@@ -12,6 +15,9 @@ console.info (x.x0);
 // tsc dies on this next line with "bug.ts (5,16): Expected ')'"
 //   tsc seems to be parsing the e0 as a hex constant.
 console.info (x.e0);
+>console.info : Symbol(Console.info, Decl(lib.d.ts, --, --))
+>console : Symbol(console, Decl(lib.d.ts, --, --))
+>info : Symbol(Console.info, Decl(lib.d.ts, --, --))
 >x.e0 : Symbol(e0, Decl(parserNotHexLiteral1.ts, 0, 9))
 >x : Symbol(x, Decl(parserNotHexLiteral1.ts, 0, 3))
 >e0 : Symbol(e0, Decl(parserNotHexLiteral1.ts, 0, 9))
diff --git a/tests/baselines/reference/parserNotHexLiteral1.types b/tests/baselines/reference/parserNotHexLiteral1.types
index 619221a0cc5..4ec11682de3 100644
--- a/tests/baselines/reference/parserNotHexLiteral1.types
+++ b/tests/baselines/reference/parserNotHexLiteral1.types
@@ -8,10 +8,10 @@ var x = {e0: 'cat', x0: 'dog'};
 >'dog' : "dog"
 
 console.info (x.x0);
->console.info (x.x0) : any
->console.info : any
->console : any
->info : any
+>console.info (x.x0) : void
+>console.info : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>info : (message?: any, ...optionalParams: any[]) => void
 >x.x0 : string
 >x : { e0: string; x0: string; }
 >x0 : string
@@ -19,10 +19,10 @@ console.info (x.x0);
 // tsc dies on this next line with "bug.ts (5,16): Expected ')'"
 //   tsc seems to be parsing the e0 as a hex constant.
 console.info (x.e0);
->console.info (x.e0) : any
->console.info : any
->console : any
->info : any
+>console.info (x.e0) : void
+>console.info : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>info : (message?: any, ...optionalParams: any[]) => void
 >x.e0 : string
 >x : { e0: string; x0: string; }
 >e0 : string
diff --git a/tests/baselines/reference/parserOverloadOnConstants1.errors.txt b/tests/baselines/reference/parserOverloadOnConstants1.errors.txt
deleted file mode 100644
index 465e29bd798..00000000000
--- a/tests/baselines/reference/parserOverloadOnConstants1.errors.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-tests/cases/conformance/parser/ecmascript5/parserOverloadOnConstants1.ts(2,37): error TS2304: Cannot find name 'HTMLElement'.
-tests/cases/conformance/parser/ecmascript5/parserOverloadOnConstants1.ts(3,39): error TS2304: Cannot find name 'HTMLCanvasElement'.
-tests/cases/conformance/parser/ecmascript5/parserOverloadOnConstants1.ts(4,36): error TS2304: Cannot find name 'HTMLDivElement'.
-tests/cases/conformance/parser/ecmascript5/parserOverloadOnConstants1.ts(5,37): error TS2304: Cannot find name 'HTMLSpanElement'.
-
-
-==== tests/cases/conformance/parser/ecmascript5/parserOverloadOnConstants1.ts (4 errors) ====
-    interface Document {
-        createElement(tagName: string): HTMLElement;
-                                        ~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'HTMLElement'.
-        createElement(tagName: 'canvas'): HTMLCanvasElement;
-                                          ~~~~~~~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'HTMLCanvasElement'.
-        createElement(tagName: 'div'): HTMLDivElement;
-                                       ~~~~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'HTMLDivElement'.
-        createElement(tagName: 'span'): HTMLSpanElement;
-                                        ~~~~~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'HTMLSpanElement'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserOverloadOnConstants1.symbols b/tests/baselines/reference/parserOverloadOnConstants1.symbols
index 4b6209cc83e..7105f32e5ec 100644
--- a/tests/baselines/reference/parserOverloadOnConstants1.symbols
+++ b/tests/baselines/reference/parserOverloadOnConstants1.symbols
@@ -1,20 +1,24 @@
 === tests/cases/conformance/parser/ecmascript5/parserOverloadOnConstants1.ts ===
 interface Document {
->Document : Symbol(Document, Decl(parserOverloadOnConstants1.ts, 0, 0))
+>Document : Symbol(Document, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(parserOverloadOnConstants1.ts, 0, 0))
 
     createElement(tagName: string): HTMLElement;
->createElement : Symbol(Document.createElement, Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56), Decl(parserOverloadOnConstants1.ts, 3, 50))
+>createElement : Symbol(Document.createElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56) ... and 1 more)
 >tagName : Symbol(tagName, Decl(parserOverloadOnConstants1.ts, 1, 18))
+>HTMLElement : Symbol(HTMLElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     createElement(tagName: 'canvas'): HTMLCanvasElement;
->createElement : Symbol(Document.createElement, Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56), Decl(parserOverloadOnConstants1.ts, 3, 50))
+>createElement : Symbol(Document.createElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56) ... and 1 more)
 >tagName : Symbol(tagName, Decl(parserOverloadOnConstants1.ts, 2, 18))
+>HTMLCanvasElement : Symbol(HTMLCanvasElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     createElement(tagName: 'div'): HTMLDivElement;
->createElement : Symbol(Document.createElement, Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56), Decl(parserOverloadOnConstants1.ts, 3, 50))
+>createElement : Symbol(Document.createElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56) ... and 1 more)
 >tagName : Symbol(tagName, Decl(parserOverloadOnConstants1.ts, 3, 18))
+>HTMLDivElement : Symbol(HTMLDivElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     createElement(tagName: 'span'): HTMLSpanElement;
->createElement : Symbol(Document.createElement, Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56), Decl(parserOverloadOnConstants1.ts, 3, 50))
+>createElement : Symbol(Document.createElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(parserOverloadOnConstants1.ts, 0, 20), Decl(parserOverloadOnConstants1.ts, 1, 48), Decl(parserOverloadOnConstants1.ts, 2, 56) ... and 1 more)
 >tagName : Symbol(tagName, Decl(parserOverloadOnConstants1.ts, 4, 18))
+>HTMLSpanElement : Symbol(HTMLSpanElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserOverloadOnConstants1.types b/tests/baselines/reference/parserOverloadOnConstants1.types
index e62c5ef3b28..3d972850bc1 100644
--- a/tests/baselines/reference/parserOverloadOnConstants1.types
+++ b/tests/baselines/reference/parserOverloadOnConstants1.types
@@ -3,22 +3,22 @@ interface Document {
 >Document : Document
 
     createElement(tagName: string): HTMLElement;
->createElement : { (tagName: string): any; (tagName: "canvas"): any; (tagName: "div"): any; (tagName: "span"): any; }
+>createElement : { <K extends "object" | "canvas" | "div" | "span" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagName: K): HTMLElementTagNameMap[K]; (tagName: string): HTMLElement; (tagName: string): HTMLElement; (tagName: "canvas"): HTMLCanvasElement; (tagName: "div"): HTMLDivElement; (tagName: "span"): HTMLSpanElement; }
 >tagName : string
->HTMLElement : No type information available!
+>HTMLElement : HTMLElement
 
     createElement(tagName: 'canvas'): HTMLCanvasElement;
->createElement : { (tagName: string): any; (tagName: "canvas"): any; (tagName: "div"): any; (tagName: "span"): any; }
+>createElement : { <K extends "object" | "canvas" | "div" | "span" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagName: K): HTMLElementTagNameMap[K]; (tagName: string): HTMLElement; (tagName: string): HTMLElement; (tagName: "canvas"): HTMLCanvasElement; (tagName: "div"): HTMLDivElement; (tagName: "span"): HTMLSpanElement; }
 >tagName : "canvas"
->HTMLCanvasElement : No type information available!
+>HTMLCanvasElement : HTMLCanvasElement
 
     createElement(tagName: 'div'): HTMLDivElement;
->createElement : { (tagName: string): any; (tagName: "canvas"): any; (tagName: "div"): any; (tagName: "span"): any; }
+>createElement : { <K extends "object" | "canvas" | "div" | "span" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagName: K): HTMLElementTagNameMap[K]; (tagName: string): HTMLElement; (tagName: string): HTMLElement; (tagName: "canvas"): HTMLCanvasElement; (tagName: "div"): HTMLDivElement; (tagName: "span"): HTMLSpanElement; }
 >tagName : "div"
->HTMLDivElement : No type information available!
+>HTMLDivElement : HTMLDivElement
 
     createElement(tagName: 'span'): HTMLSpanElement;
->createElement : { (tagName: string): any; (tagName: "canvas"): any; (tagName: "div"): any; (tagName: "span"): any; }
+>createElement : { <K extends "object" | "canvas" | "div" | "span" | "a" | "applet" | "area" | "audio" | "base" | "basefont" | "blockquote" | "body" | "br" | "button" | "caption" | "col" | "colgroup" | "data" | "datalist" | "del" | "dir" | "dl" | "embed" | "fieldset" | "font" | "form" | "frame" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "hr" | "html" | "iframe" | "img" | "input" | "ins" | "isindex" | "label" | "legend" | "li" | "link" | "listing" | "map" | "marquee" | "menu" | "meta" | "meter" | "nextid" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "pre" | "progress" | "q" | "script" | "select" | "source" | "style" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "ul" | "video" | "x-ms-webview" | "xmp">(tagName: K): HTMLElementTagNameMap[K]; (tagName: string): HTMLElement; (tagName: string): HTMLElement; (tagName: "canvas"): HTMLCanvasElement; (tagName: "div"): HTMLDivElement; (tagName: "span"): HTMLSpanElement; }
 >tagName : "span"
->HTMLSpanElement : No type information available!
+>HTMLSpanElement : HTMLSpanElement
 }
diff --git a/tests/baselines/reference/parserRealSource1.symbols b/tests/baselines/reference/parserRealSource1.symbols
index 4b5cc378607..245d5082f08 100644
--- a/tests/baselines/reference/parserRealSource1.symbols
+++ b/tests/baselines/reference/parserRealSource1.symbols
@@ -288,7 +288,7 @@ module TypeScript {
 
         var start = +new Date();
 >start : Symbol(start, Decl(parserRealSource1.ts, 97, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var result = func();
 >result : Symbol(result, Decl(parserRealSource1.ts, 98, 11))
@@ -296,7 +296,7 @@ module TypeScript {
 
         var end = +new Date();
 >end : Symbol(end, Decl(parserRealSource1.ts, 99, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         logger.log(funcDescription + " completed in " + (end - start) + " msec");
 >logger.log : Symbol(ILogger.log, Decl(parserRealSource1.ts, 43, 25))
diff --git a/tests/baselines/reference/parserRealSource5.symbols b/tests/baselines/reference/parserRealSource5.symbols
index 5feaa2b7b4c..2cdc694da62 100644
--- a/tests/baselines/reference/parserRealSource5.symbols
+++ b/tests/baselines/reference/parserRealSource5.symbols
@@ -50,11 +50,11 @@ module TypeScript {
 >startLine : Symbol(PrintContext.startLine, Decl(parserRealSource5.ts, 22, 9))
 
             if (this.builder.length > 0) {
->this.builder.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>this.builder.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >this.builder : Symbol(PrintContext.builder, Decl(parserRealSource5.ts, 7, 31))
 >this : Symbol(PrintContext, Decl(parserRealSource5.ts, 5, 19))
 >builder : Symbol(PrintContext.builder, Decl(parserRealSource5.ts, 7, 31))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 
                 CompilerDiagnostics.Alert(this.builder);
 >this.builder : Symbol(PrintContext.builder, Decl(parserRealSource5.ts, 7, 31))
diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols
index 4622f37a0e4..5fa1c93f846 100644
--- a/tests/baselines/reference/parserSymbolProperty1.symbols
+++ b/tests/baselines/reference/parserSymbolProperty1.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0))
 
     [Symbol.iterator]: string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols
index f5bb7fa0f53..b8c2f118687 100644
--- a/tests/baselines/reference/parserSymbolProperty2.symbols
+++ b/tests/baselines/reference/parserSymbolProperty2.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0))
 
     [Symbol.unscopables](): string;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols
index 9d2266ad4b7..233fc9d71c2 100644
--- a/tests/baselines/reference/parserSymbolProperty3.symbols
+++ b/tests/baselines/reference/parserSymbolProperty3.symbols
@@ -3,7 +3,7 @@ declare class C {
 >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0))
 
     [Symbol.unscopables](): string;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols
index e37cb6bc011..08875ac8b75 100644
--- a/tests/baselines/reference/parserSymbolProperty4.symbols
+++ b/tests/baselines/reference/parserSymbolProperty4.symbols
@@ -3,7 +3,7 @@ declare class C {
 >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0))
 
     [Symbol.toPrimitive]: string;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols
index f8fb7d93417..7551b5547f8 100644
--- a/tests/baselines/reference/parserSymbolProperty5.symbols
+++ b/tests/baselines/reference/parserSymbolProperty5.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0))
 
     [Symbol.toPrimitive]: string;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols
index 7fb83ea9ffa..0dfddafce54 100644
--- a/tests/baselines/reference/parserSymbolProperty6.symbols
+++ b/tests/baselines/reference/parserSymbolProperty6.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0))
 
     [Symbol.toStringTag]: string = "";
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols
index 8d71cbb1a0d..9aa7f9f20d4 100644
--- a/tests/baselines/reference/parserSymbolProperty7.symbols
+++ b/tests/baselines/reference/parserSymbolProperty7.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0))
 
     [Symbol.toStringTag](): void { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols
index e20dd2dbba4..4e04cd3ebd6 100644
--- a/tests/baselines/reference/parserSymbolProperty8.symbols
+++ b/tests/baselines/reference/parserSymbolProperty8.symbols
@@ -3,7 +3,7 @@ var x: {
 >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3))
 
     [Symbol.toPrimitive](): string
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols
index c70643c254a..b0383007944 100644
--- a/tests/baselines/reference/parserSymbolProperty9.symbols
+++ b/tests/baselines/reference/parserSymbolProperty9.symbols
@@ -3,7 +3,7 @@ var x: {
 >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3))
 
     [Symbol.toPrimitive]: string
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserharness.symbols b/tests/baselines/reference/parserharness.symbols
index 8382d6ab41a..85fcd37d626 100644
--- a/tests/baselines/reference/parserharness.symbols
+++ b/tests/baselines/reference/parserharness.symbols
@@ -43,9 +43,9 @@ function switchToForwardSlashes(path: string) {
 >path : Symbol(path, Decl(parserharness.ts, 27, 32))
 
     return path.replace(/\\/g, "/");
->path.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>path.replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >path : Symbol(path, Decl(parserharness.ts, 27, 32))
->replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
 
 function filePath(fullPath: string) {
@@ -59,23 +59,23 @@ function filePath(fullPath: string) {
 
     var components = fullPath.split("/");
 >components : Symbol(components, Decl(parserharness.ts, 33, 7))
->fullPath.split : Symbol(String.split, Decl(lib.d.ts, --, --))
+>fullPath.split : Symbol(String.split, Decl(lib.es5.d.ts, --, --))
 >fullPath : Symbol(fullPath, Decl(parserharness.ts, 31, 18))
->split : Symbol(String.split, Decl(lib.d.ts, --, --))
+>split : Symbol(String.split, Decl(lib.es5.d.ts, --, --))
 
     var path: string[] = components.slice(0, components.length - 1);
 >path : Symbol(path, Decl(parserharness.ts, 34, 7))
->components.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>components.slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --))
 >components : Symbol(components, Decl(parserharness.ts, 33, 7))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
->components.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --))
+>components.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >components : Symbol(components, Decl(parserharness.ts, 33, 7))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
     return path.join("/") + "/";
->path.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>path.join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 >path : Symbol(path, Decl(parserharness.ts, 34, 7))
->join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 }
 
 var typescriptServiceFileName = filePath(IO.getExecutingFilePath()) + "typescriptServices.js";
@@ -90,7 +90,7 @@ var typescriptServiceFile = IO.readFile(typescriptServiceFileName);
 
 if (typeof ActiveXObject === "function") {
     eval(typescriptServiceFile);
->eval : Symbol(eval, Decl(lib.d.ts, --, --))
+>eval : Symbol(eval, Decl(lib.es5.d.ts, --, --))
 >typescriptServiceFile : Symbol(typescriptServiceFile, Decl(parserharness.ts, 39, 3))
 
 } else if (typeof require === "function") {
@@ -103,7 +103,7 @@ if (typeof ActiveXObject === "function") {
 
 } else {
     throw new Error('Unknown context');
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
 
 declare module process {
@@ -117,7 +117,7 @@ declare module process {
 >on : Symbol(on, Decl(parserharness.ts, 50, 56))
 >event : Symbol(event, Decl(parserharness.ts, 51, 23))
 >listener : Symbol(listener, Decl(parserharness.ts, 51, 37))
->Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
 
 module Harness {
@@ -129,9 +129,9 @@ module Harness {
 
     var global = <any>Function("return this").call(null);
 >global : Symbol(global, Decl(parserharness.ts, 57, 7))
->Function("return this").call : Symbol(Function.call, Decl(lib.d.ts, --, --))
->Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->call : Symbol(Function.call, Decl(lib.d.ts, --, --))
+>Function("return this").call : Symbol(Function.call, Decl(lib.es5.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>call : Symbol(Function.call, Decl(lib.es5.d.ts, --, --))
 
     export var usePull = false;
 >usePull : Symbol(usePull, Decl(parserharness.ts, 58, 14))
@@ -194,7 +194,7 @@ module Harness {
         export var throwAssertError = (error: Error) => {
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
 >error : Symbol(error, Decl(parserharness.ts, 82, 39))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
             throw error;
 >error : Symbol(error, Decl(parserharness.ts, 82, 39))
@@ -207,15 +207,15 @@ module Harness {
 >id : Symbol(id, Decl(parserharness.ts, 87, 28))
 
             if (bugIds.indexOf(id) < 0) {
->bugIds.indexOf : Symbol(Array.indexOf, Decl(lib.d.ts, --, --))
+>bugIds.indexOf : Symbol(Array.indexOf, Decl(lib.es5.d.ts, --, --))
 >bugIds : Symbol(bugIds, Decl(parserharness.ts, 81, 18))
->indexOf : Symbol(Array.indexOf, Decl(lib.d.ts, --, --))
+>indexOf : Symbol(Array.indexOf, Decl(lib.es5.d.ts, --, --))
 >id : Symbol(id, Decl(parserharness.ts, 87, 28))
 
                 bugIds.push(id);
->bugIds.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>bugIds.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >bugIds : Symbol(bugIds, Decl(parserharness.ts, 81, 18))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >id : Symbol(id, Decl(parserharness.ts, 87, 28))
             }
         }
@@ -227,17 +227,17 @@ module Harness {
 
             var bugs = content.match(/\bbug (\d+)/i);
 >bugs : Symbol(bugs, Decl(parserharness.ts, 95, 15))
->content.match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>content.match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >content : Symbol(content, Decl(parserharness.ts, 94, 29))
->match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 
             if (bugs) {
 >bugs : Symbol(bugs, Decl(parserharness.ts, 95, 15))
 
                 bugs.forEach(bug => assert.bug(bug));
->bugs.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>bugs.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >bugs : Symbol(bugs, Decl(parserharness.ts, 95, 15))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >bug : Symbol(bug, Decl(parserharness.ts, 97, 29))
 >assert : Symbol(assert, Decl(parserharness.ts, 20, 11))
 >bug : Symbol(bug, Decl(parserharness.ts, 97, 29))
@@ -254,7 +254,7 @@ module Harness {
 
                 throwAssertError(new Error(msg || "Expected true, got false."));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >msg : Symbol(msg, Decl(parserharness.ts, 101, 43))
             }
         }
@@ -265,18 +265,18 @@ module Harness {
 >length : Symbol(length, Decl(parserharness.ts, 107, 49))
 
             if (arr.length != length) {
->arr.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>arr.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(parserharness.ts, 107, 38))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >length : Symbol(length, Decl(parserharness.ts, 107, 49))
 
                 var actual = '';
 >actual : Symbol(actual, Decl(parserharness.ts, 109, 19))
 
                 arr.forEach(n => actual = actual + '\n      ' + n.toString());
->arr.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(parserharness.ts, 107, 38))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >n : Symbol(n, Decl(parserharness.ts, 110, 28))
 >actual : Symbol(actual, Decl(parserharness.ts, 109, 19))
 >actual : Symbol(actual, Decl(parserharness.ts, 109, 19))
@@ -284,7 +284,7 @@ module Harness {
 
                 throwAssertError(new Error('Expected array to have ' + length + ' elements. Actual elements were:' + actual));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >length : Symbol(length, Decl(parserharness.ts, 107, 49))
 >actual : Symbol(actual, Decl(parserharness.ts, 109, 19))
             }
@@ -301,7 +301,7 @@ module Harness {
 
                 throwAssertError(new Error("Expected " + actual + " to equal " + expected));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >actual : Symbol(actual, Decl(parserharness.ts, 115, 30))
 >expected : Symbol(expected, Decl(parserharness.ts, 115, 37))
             }
@@ -318,7 +318,7 @@ module Harness {
 
                 throwAssertError(new Error("Expected " + actual + " to *not* equal " + expected));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >actual : Symbol(actual, Decl(parserharness.ts, 121, 33))
 >expected : Symbol(expected, Decl(parserharness.ts, 121, 40))
             }
@@ -333,7 +333,7 @@ module Harness {
 
                 throwAssertError(new Error("Expected " + result + " to *not* be null"));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 127, 32))
             }
         }
@@ -359,11 +359,11 @@ module Harness {
 >actual : Symbol(actual, Decl(parserharness.ts, 135, 19))
 
                 result.errors.forEach(err => {
->result.errors.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>result.errors.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >result.errors : Symbol(Compiler.CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
 >result : Symbol(result, Decl(parserharness.ts, 133, 40))
 >errors : Symbol(Compiler.CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >err : Symbol(err, Decl(parserharness.ts, 136, 38))
 
                     actual = actual + '\n     ' + err.toString();
@@ -377,7 +377,7 @@ module Harness {
 
                 throwAssertError(new Error("Expected compiler warning at (" + line + ", " + column + "): " + desc + "\nActual errors follow: " + actual));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >line : Symbol(line, Decl(parserharness.ts, 133, 72))
 >column : Symbol(column, Decl(parserharness.ts, 133, 86))
 >desc : Symbol(desc, Decl(parserharness.ts, 133, 102))
@@ -442,7 +442,7 @@ module Harness {
                 }
                 throwAssertError(new Error(errorString));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >errorString : Symbol(errorString, Decl(parserharness.ts, 149, 19))
             }
         }
@@ -458,9 +458,9 @@ module Harness {
             for (var i = 0; i < contains.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 166, 20))
 >i : Symbol(i, Decl(parserharness.ts, 166, 20))
->contains.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>contains.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >contains : Symbol(contains, Decl(parserharness.ts, 163, 49))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 166, 20))
 
                 found = false;
@@ -469,9 +469,9 @@ module Harness {
                 for (var j = 0; j < arr.length; j++) {
 >j : Symbol(j, Decl(parserharness.ts, 169, 24))
 >j : Symbol(j, Decl(parserharness.ts, 169, 24))
->arr.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>arr.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(parserharness.ts, 163, 38))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >j : Symbol(j, Decl(parserharness.ts, 169, 24))
 
                     if (arr[j] === contains[i]) {
@@ -492,7 +492,7 @@ module Harness {
 
                     throwAssertError(new Error("Expected array to contain \"" + contains[i] + "\""));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >contains : Symbol(contains, Decl(parserharness.ts, 163, 49))
 >i : Symbol(i, Decl(parserharness.ts, 166, 20))
                 }
@@ -511,9 +511,9 @@ module Harness {
             for (var i = 0; i < arr.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 185, 20))
 >i : Symbol(i, Decl(parserharness.ts, 185, 20))
->arr.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>arr.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(parserharness.ts, 182, 42))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 185, 20))
 
                 if (filter(arr[i])) {
@@ -531,7 +531,7 @@ module Harness {
 
                 throwAssertError(new Error("Expected array to match element only once (instead of " + foundCount + " times)"));
 >throwAssertError : Symbol(throwAssertError, Decl(parserharness.ts, 82, 18))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >foundCount : Symbol(foundCount, Decl(parserharness.ts, 183, 15))
             }
         }
@@ -547,20 +547,20 @@ module Harness {
         // we have to string-based splitting instead and try to figure out the delimiting chars
         var lines = content.split('\r\n');
 >lines : Symbol(lines, Decl(parserharness.ts, 202, 11))
->content.split : Symbol(String.split, Decl(lib.d.ts, --, --))
+>content.split : Symbol(String.split, Decl(lib.es5.d.ts, --, --))
 >content : Symbol(content, Decl(parserharness.ts, 198, 43))
->split : Symbol(String.split, Decl(lib.d.ts, --, --))
+>split : Symbol(String.split, Decl(lib.es5.d.ts, --, --))
 
         if (lines.length === 1) {
->lines.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>lines.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >lines : Symbol(lines, Decl(parserharness.ts, 202, 11))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
             lines = content.split('\n');
 >lines : Symbol(lines, Decl(parserharness.ts, 202, 11))
->content.split : Symbol(String.split, Decl(lib.d.ts, --, --))
+>content.split : Symbol(String.split, Decl(lib.es5.d.ts, --, --))
 >content : Symbol(content, Decl(parserharness.ts, 198, 43))
->split : Symbol(String.split, Decl(lib.d.ts, --, --))
+>split : Symbol(String.split, Decl(lib.es5.d.ts, --, --))
         }
         return lines;
 >lines : Symbol(lines, Decl(parserharness.ts, 202, 11))
@@ -572,9 +572,9 @@ module Harness {
 >path : Symbol(path, Decl(parserharness.ts, 210, 29))
 
         if (path.indexOf('tests') < 0) {
->path.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
+>path.indexOf : Symbol(String.indexOf, Decl(lib.es5.d.ts, --, --))
 >path : Symbol(path, Decl(parserharness.ts, 210, 29))
->indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
+>indexOf : Symbol(String.indexOf, Decl(lib.es5.d.ts, --, --))
 
             path = "tests/" + path;
 >path : Symbol(path, Decl(parserharness.ts, 210, 29))
@@ -593,7 +593,7 @@ module Harness {
 >content : Symbol(content, Decl(parserharness.ts, 216, 11))
 
             throw new Error("failed to read file at: '" + Harness.userSpecifiedroot + path + "'");
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Harness.userSpecifiedroot : Symbol(userSpecifiedroot, Decl(parserharness.ts, 56, 14))
 >Harness : Symbol(Harness, Decl(parserharness.ts, 52, 1))
 >userSpecifiedroot : Symbol(userSpecifiedroot, Decl(parserharness.ts, 56, 14))
@@ -627,7 +627,7 @@ module Harness {
 >scenario : Symbol(scenario, Decl(parserharness.ts, 229, 22))
 >IScenarioMetadata : Symbol(IScenarioMetadata, Decl(parserharness.ts, 71, 5))
 >error : Symbol(error, Decl(parserharness.ts, 229, 50))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         testStart: (test: ITestMetadata) => void;
 >testStart : Symbol(ILogger.testStart, Decl(parserharness.ts, 229, 74))
@@ -654,7 +654,7 @@ module Harness {
 >test : Symbol(test, Decl(parserharness.ts, 234, 16))
 >ITestMetadata : Symbol(ITestMetadata, Decl(parserharness.ts, 58, 31))
 >error : Symbol(error, Decl(parserharness.ts, 234, 36))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         comment: (comment: string) => void;
 >comment : Symbol(ILogger.comment, Decl(parserharness.ts, 234, 59))
@@ -693,7 +693,7 @@ module Harness {
 >scenario : Symbol(scenario, Decl(parserharness.ts, 243, 27))
 >IScenarioMetadata : Symbol(IScenarioMetadata, Decl(parserharness.ts, 71, 5))
 >error : Symbol(error, Decl(parserharness.ts, 243, 55))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         public testStart(test: ITestMetadata) { }
 >testStart : Symbol(Logger.testStart, Decl(parserharness.ts, 243, 74))
@@ -720,7 +720,7 @@ module Harness {
 >test : Symbol(test, Decl(parserharness.ts, 248, 21))
 >ITestMetadata : Symbol(ITestMetadata, Decl(parserharness.ts, 58, 31))
 >error : Symbol(error, Decl(parserharness.ts, 248, 41))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         public comment(comment: string) { }
 >comment : Symbol(Logger.comment, Decl(parserharness.ts, 248, 59))
@@ -747,9 +747,9 @@ module Harness {
 >ILogger : Symbol(ILogger, Decl(parserharness.ts, 222, 5))
 
         loggers.push(logger);
->loggers.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>loggers.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >loggers : Symbol(loggers, Decl(parserharness.ts, 254, 7))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >logger : Symbol(logger, Decl(parserharness.ts, 255, 35))
     }
     export function emitLog(field: string, ...params: any[]) {
@@ -760,9 +760,9 @@ module Harness {
         for (var i = 0; i < loggers.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 259, 16))
 >i : Symbol(i, Decl(parserharness.ts, 259, 16))
->loggers.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>loggers.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >loggers : Symbol(loggers, Decl(parserharness.ts, 254, 7))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 259, 16))
 
             if (typeof loggers[i][field] === 'function') {
@@ -787,7 +787,7 @@ module Harness {
 
         (e?: Error): void;
 >e : Symbol(e, Decl(parserharness.ts, 268, 9))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
     }
     export class Runnable {
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
@@ -804,7 +804,7 @@ module Harness {
         // The error, if any, that occurred when running 'block'
         public error: Error = null;
 >error : Symbol(Runnable.error, Decl(parserharness.ts, 274, 45))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         // Whether or not this object has any failures (including in its descendants)
         public passed = null;
@@ -825,11 +825,11 @@ module Harness {
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 
             this.children.push(child);
->this.children.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.children.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.children : Symbol(Runnable.children, Decl(parserharness.ts, 283, 35))
 >this : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >children : Symbol(Runnable.children, Decl(parserharness.ts, 283, 35))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >child : Symbol(child, Decl(parserharness.ts, 288, 24))
         }
 
@@ -850,9 +850,9 @@ module Harness {
 
             try {
                 if (fn.length === 0) {
->fn.length : Symbol(Function.length, Decl(lib.d.ts, --, --))
+>fn.length : Symbol(Function.length, Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(parserharness.ts, 296, 20))
->length : Symbol(Function.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Function.length, Decl(lib.es5.d.ts, --, --))
 
                     // No async.
                     fn();
@@ -946,7 +946,7 @@ module Harness {
         static errorHandlerStack: { (e: Error): void; }[] = [];
 >errorHandlerStack : Symbol(Runnable.errorHandlerStack, Decl(parserharness.ts, 335, 9))
 >e : Symbol(e, Decl(parserharness.ts, 337, 37))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
         static pushGlobalErrorHandler(done: IDone) {
 >pushGlobalErrorHandler : Symbol(Runnable.pushGlobalErrorHandler, Decl(parserharness.ts, 337, 63))
@@ -972,7 +972,7 @@ module Harness {
         static handleError(e: Error) {
 >handleError : Symbol(Runnable.handleError, Decl(parserharness.ts, 347, 9))
 >e : Symbol(e, Decl(parserharness.ts, 349, 27))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
             if (errorHandlerStack.length === 0) {
                 IO.printLine('Global error: ' + e);
@@ -1023,7 +1023,7 @@ module Harness {
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 
             throw new Error("Testcases may not be nested inside other testcases");
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
         }
 
         /** Run the test case block and fail the test if it raised an error. If no error is raised, the test passes. */
@@ -1037,11 +1037,11 @@ module Harness {
 >this : Symbol(TestCase, Decl(parserharness.ts, 356, 5))
 
             Runnable.currentStack.push(this);
->Runnable.currentStack.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this : Symbol(TestCase, Decl(parserharness.ts, 356, 5))
 
             emitLog('testStart', { desc: this.description });
@@ -1096,11 +1096,11 @@ module Harness {
                     }
 
                     Runnable.currentStack.pop();
->Runnable.currentStack.pop : Symbol(Array.pop, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.pop : Symbol(Array.pop, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->pop : Symbol(Array.pop, Decl(lib.d.ts, --, --))
+>pop : Symbol(Array.pop, Decl(lib.es5.d.ts, --, --))
 
                     done()
 >done : Symbol(done, Decl(parserharness.ts, 372, 19))
@@ -1154,11 +1154,11 @@ module Harness {
 >this : Symbol(Scenario, Decl(parserharness.ts, 398, 5))
 
             Runnable.currentStack.push(this);
->Runnable.currentStack.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this : Symbol(Scenario, Decl(parserharness.ts, 398, 5))
 
             emitLog('scenarioStart', { desc: this.description });
@@ -1176,11 +1176,11 @@ module Harness {
 >e : Symbol(e, Decl(parserharness.ts, 418, 53))
 
                 Runnable.currentStack.pop();
->Runnable.currentStack.pop : Symbol(Array.pop, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.pop : Symbol(Array.pop, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->pop : Symbol(Array.pop, Decl(lib.d.ts, --, --))
+>pop : Symbol(Array.pop, Decl(lib.es5.d.ts, --, --))
 
                 if (e) {
 >e : Symbol(e, Decl(parserharness.ts, 418, 53))
@@ -1256,11 +1256,11 @@ module Harness {
 
             for (; index < this.children.length; index++) {
 >index : Symbol(index, Decl(parserharness.ts, 439, 39))
->this.children.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.children.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.children : Symbol(Runnable.children, Decl(parserharness.ts, 283, 35))
 >this : Symbol(Scenario, Decl(parserharness.ts, 398, 5))
 >children : Symbol(Runnable.children, Decl(parserharness.ts, 283, 35))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >index : Symbol(index, Decl(parserharness.ts, 439, 39))
 
                 async = this.runChild(index, <any>function (e) {
@@ -1369,11 +1369,11 @@ module Harness {
 
             for (; index < this.children.length; index++) {
 >index : Symbol(index, Decl(parserharness.ts, 473, 27))
->this.children.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.children.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.children : Symbol(Runnable.children, Decl(parserharness.ts, 283, 35))
 >this : Symbol(Run, Decl(parserharness.ts, 462, 5))
 >children : Symbol(Runnable.children, Decl(parserharness.ts, 283, 35))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >index : Symbol(index, Decl(parserharness.ts, 473, 27))
 
                 // Clear out bug descriptions
@@ -1474,9 +1474,9 @@ module Harness {
 >now : Symbol(now, Decl(parserharness.ts, 500, 22))
 
                     return Date.now();
->Date.now : Symbol(DateConstructor.now, Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->now : Symbol(DateConstructor.now, Decl(lib.d.ts, --, --))
+>Date.now : Symbol(DateConstructor.now, Decl(lib.es5.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>now : Symbol(DateConstructor.now, Decl(lib.es5.d.ts, --, --))
                 }
 
                 resolution = 1000;
@@ -1541,11 +1541,11 @@ module Harness {
 >value : Symbol(value, Decl(parserharness.ts, 548, 23))
 
                 this.data.push(value);
->this.data.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.data.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >value : Symbol(value, Decl(parserharness.ts, 548, 23))
             }
 
@@ -1558,11 +1558,11 @@ module Harness {
                 for (var i = 0; i < this.data.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 554, 24))
 >i : Symbol(i, Decl(parserharness.ts, 554, 24))
->this.data.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.data.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 554, 24))
 
                     sum += this.data[i];
@@ -1575,11 +1575,11 @@ module Harness {
 
                 return sum / this.data.length;
 >sum : Symbol(sum, Decl(parserharness.ts, 553, 19))
->this.data.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.data.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
             }
 
             public min() {
@@ -1594,11 +1594,11 @@ module Harness {
                 for (var i = 1; i < this.data.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 564, 24))
 >i : Symbol(i, Decl(parserharness.ts, 564, 24))
->this.data.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.data.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 564, 24))
 
                     if (this.data[i] < min) {
@@ -1633,11 +1633,11 @@ module Harness {
                 for (var i = 1; i < this.data.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 576, 24))
 >i : Symbol(i, Decl(parserharness.ts, 576, 24))
->this.data.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.data.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 576, 24))
 
                     if (this.data[i] > max) {
@@ -1675,18 +1675,18 @@ module Harness {
                 for (var i = 0; i < this.data.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 588, 24))
 >i : Symbol(i, Decl(parserharness.ts, 588, 24))
->this.data.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.data.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 588, 24))
 
                     sumOfSquares += Math.pow(this.data[i] - sampleMean, 2);
 >sumOfSquares : Symbol(sumOfSquares, Decl(parserharness.ts, 587, 19))
->Math.pow : Symbol(Math.pow, Decl(lib.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->pow : Symbol(Math.pow, Decl(lib.d.ts, --, --))
+>Math.pow : Symbol(Math.pow, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>pow : Symbol(Math.pow, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
@@ -1695,15 +1695,15 @@ module Harness {
                 }
 
                 return Math.sqrt(sumOfSquares / this.data.length);
->Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --))
+>Math.sqrt : Symbol(Math.sqrt, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>sqrt : Symbol(Math.sqrt, Decl(lib.es5.d.ts, --, --))
 >sumOfSquares : Symbol(sumOfSquares, Decl(parserharness.ts, 587, 19))
->this.data.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.data.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
 >this : Symbol(Dataset, Decl(parserharness.ts, 543, 9))
 >data : Symbol(Dataset.data, Decl(parserharness.ts, 545, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
             }
         }
 
@@ -1837,9 +1837,9 @@ module Harness {
             }
 
             f.call(benchmark, subBenchmark);
->f.call : Symbol(Function.call, Decl(lib.d.ts, --, --))
+>f.call : Symbol(Function.call, Decl(lib.es5.d.ts, --, --))
 >f : Symbol(f, Decl(parserharness.ts, 625, 30))
->call : Symbol(Function.call, Decl(lib.d.ts, --, --))
+>call : Symbol(Function.call, Decl(lib.es5.d.ts, --, --))
 >benchmark : Symbol(benchmark, Decl(parserharness.ts, 622, 33))
 >subBenchmark : Symbol(subBenchmark, Decl(parserharness.ts, 632, 15))
 
@@ -1864,9 +1864,9 @@ module Harness {
             for (var i = 0; i < benchmarks.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 644, 20))
 >i : Symbol(i, Decl(parserharness.ts, 644, 20))
->benchmarks.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>benchmarks.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >benchmarks : Symbol(benchmarks, Decl(parserharness.ts, 613, 18))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 644, 20))
 
                 var b = new benchmarks[i]();
@@ -1998,9 +1998,9 @@ module Harness {
 >BenchmarkClass : Symbol(BenchmarkClass, Decl(parserharness.ts, 679, 37))
 
             benchmarks.push(BenchmarkClass);
->benchmarks.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>benchmarks.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >benchmarks : Symbol(benchmarks, Decl(parserharness.ts, 613, 18))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >BenchmarkClass : Symbol(BenchmarkClass, Decl(parserharness.ts, 679, 37))
         }
 
@@ -2038,11 +2038,11 @@ module Harness {
 >str : Symbol(str, Decl(parserharness.ts, 698, 29))
 
                 this.lines.push(this.currentLine + str);
->this.lines.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.lines.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
 >this : Symbol(WriterAggregator, Decl(parserharness.ts, 686, 28))
 >lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.currentLine : Symbol(WriterAggregator.currentLine, Decl(parserharness.ts, 691, 40))
 >this : Symbol(WriterAggregator, Decl(parserharness.ts, 686, 28))
 >currentLine : Symbol(WriterAggregator.currentLine, Decl(parserharness.ts, 691, 40))
@@ -2058,16 +2058,16 @@ module Harness {
 >Close : Symbol(WriterAggregator.Close, Decl(parserharness.ts, 701, 13))
 
                 if (this.currentLine.length > 0) { this.lines.push(this.currentLine); }
->this.currentLine.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>this.currentLine.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >this.currentLine : Symbol(WriterAggregator.currentLine, Decl(parserharness.ts, 691, 40))
 >this : Symbol(WriterAggregator, Decl(parserharness.ts, 686, 28))
 >currentLine : Symbol(WriterAggregator.currentLine, Decl(parserharness.ts, 691, 40))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
->this.lines.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>this.lines.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
 >this : Symbol(WriterAggregator, Decl(parserharness.ts, 686, 28))
 >lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.currentLine : Symbol(WriterAggregator.currentLine, Decl(parserharness.ts, 691, 40))
 >this : Symbol(WriterAggregator, Decl(parserharness.ts, 686, 28))
 >currentLine : Symbol(WriterAggregator.currentLine, Decl(parserharness.ts, 691, 40))
@@ -2180,11 +2180,11 @@ module Harness {
 >fileCollection : Symbol(EmitterIOHost.fileCollection, Decl(parserharness.ts, 715, 72))
 
                     if (this.fileCollection.hasOwnProperty(p)) {
->this.fileCollection.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
+>this.fileCollection.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --))
 >this.fileCollection : Symbol(EmitterIOHost.fileCollection, Decl(parserharness.ts, 715, 72))
 >this : Symbol(EmitterIOHost, Decl(parserharness.ts, 712, 9))
 >fileCollection : Symbol(EmitterIOHost.fileCollection, Decl(parserharness.ts, 715, 72))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(parserharness.ts, 740, 24))
 
                         var current = <Harness.Compiler.WriterAggregator>this.fileCollection[p];
@@ -2198,25 +2198,25 @@ module Harness {
 >p : Symbol(p, Decl(parserharness.ts, 740, 24))
 
                         if (current.lines.length > 0) {
->current.lines.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>current.lines.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >current.lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
 >current : Symbol(current, Decl(parserharness.ts, 742, 27))
 >lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                             if (p !== '0.js') { current.lines.unshift('////[' + p + ']'); }
 >p : Symbol(p, Decl(parserharness.ts, 740, 24))
->current.lines.unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --))
+>current.lines.unshift : Symbol(Array.unshift, Decl(lib.es5.d.ts, --, --))
 >current.lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
 >current : Symbol(current, Decl(parserharness.ts, 742, 27))
 >lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
->unshift : Symbol(Array.unshift, Decl(lib.d.ts, --, --))
+>unshift : Symbol(Array.unshift, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(parserharness.ts, 740, 24))
 
                             result.push({ filename: p, file: this.fileCollection[p] });
->result.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 738, 19))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >filename : Symbol(filename, Decl(parserharness.ts, 745, 41))
 >p : Symbol(p, Decl(parserharness.ts, 740, 24))
 >file : Symbol(file, Decl(parserharness.ts, 745, 54))
@@ -2257,8 +2257,8 @@ module Harness {
 >filename : Symbol(filename, Decl(parserharness.ts, 759, 38))
 
             return /\.d\.ts$/.test(filename);
->/\.d\.ts$/.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
->test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>/\.d\.ts$/.test : Symbol(RegExp.test, Decl(lib.es5.d.ts, --, --))
+>test : Symbol(RegExp.test, Decl(lib.es5.d.ts, --, --))
 >filename : Symbol(filename, Decl(parserharness.ts, 759, 38))
         }
 
@@ -2371,15 +2371,15 @@ module Harness {
 >arg : Symbol(arg, Decl(parserharness.ts, 806, 36))
 
                 if ((Array.isArray && Array.isArray(arg)) || arg instanceof Array)
->Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --))
->Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --))
+>Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>isArray : Symbol(ArrayConstructor.isArray, Decl(lib.es5.d.ts, --, --))
+>Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.es5.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>isArray : Symbol(ArrayConstructor.isArray, Decl(lib.es5.d.ts, --, --))
 >arg : Symbol(arg, Decl(parserharness.ts, 806, 36))
 >arg : Symbol(arg, Decl(parserharness.ts, 806, 36))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
                     return arg;
 >arg : Symbol(arg, Decl(parserharness.ts, 806, 36))
@@ -2516,7 +2516,7 @@ module Harness {
 >i : Symbol(i, Decl(parserharness.ts, 861, 24))
 
                         throw new Error("Expected " + this.type + " to be a subtype of " + others[i].type);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
 >this : Symbol(Type, Decl(parserharness.ts, 800, 9))
 >type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
@@ -2551,7 +2551,7 @@ module Harness {
 >i : Symbol(i, Decl(parserharness.ts, 871, 24))
 
                         throw new Error("Expected " + this.type + " to be a subtype of " + others[i].type);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
 >this : Symbol(Type, Decl(parserharness.ts, 800, 9))
 >type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
@@ -2659,7 +2659,7 @@ module Harness {
 >other : Symbol(other, Decl(parserharness.ts, 912, 23))
 
                         throw new Error("Expected " + this.type + " to be assignment compatible with " + other.type);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
 >this : Symbol(Type, Decl(parserharness.ts, 800, 9))
 >type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
@@ -2697,7 +2697,7 @@ module Harness {
 >other : Symbol(other, Decl(parserharness.ts, 924, 23))
 
                         throw new Error("Expected " + this.type + " to not be assignment compatible with " + other.type);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
 >this : Symbol(Type, Decl(parserharness.ts, 800, 9))
 >type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
@@ -2819,7 +2819,7 @@ module Harness {
                 }
                 else {
                     throw new Error("Expected string or number not " + (typeof target));
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >target : Symbol(target, Decl(parserharness.ts, 957, 37))
                 }
 
@@ -2843,7 +2843,7 @@ module Harness {
 >errors : Symbol(errors, Decl(parserharness.ts, 970, 19))
 
                     throw new Error("Type definition contains errors: " + errors.join(","));
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >errors : Symbol(errors, Decl(parserharness.ts, 970, 19))
 
                 var matchingIdentifiers: Type[] = [];
@@ -2889,9 +2889,9 @@ module Harness {
 >targetIdentifier : Symbol(targetIdentifier, Decl(parserharness.ts, 958, 19))
 
                                 matchingIdentifiers.push(new Type(entries[i].type, code, targetIdentifier));
->matchingIdentifiers.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >Type : Symbol(Type, Decl(parserharness.ts, 800, 9))
 >entries : Symbol(entries, Decl(parserharness.ts, 987, 27))
 >i : Symbol(i, Decl(parserharness.ts, 989, 32))
@@ -2940,9 +2940,9 @@ module Harness {
 >name : Symbol(name, Decl(parserharness.ts, 1002, 35), Decl(parserharness.ts, 1011, 39))
 
                                 if (!matchingIdentifiers.some(value => (value.identifier === foundValue.identifier) && (value.code === foundValue.code) && (value.type === foundValue.type))) {
->matchingIdentifiers.some : Symbol(Array.some, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->some : Symbol(Array.some, Decl(lib.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >value : Symbol(value, Decl(parserharness.ts, 1004, 62))
 >value.identifier : Symbol(Type.identifier, Decl(parserharness.ts, 804, 49))
 >value : Symbol(value, Decl(parserharness.ts, 1004, 62))
@@ -2964,9 +2964,9 @@ module Harness {
 >type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
 
                                     matchingIdentifiers.push(foundValue);
->matchingIdentifiers.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >foundValue : Symbol(foundValue, Decl(parserharness.ts, 1003, 35), Decl(parserharness.ts, 1013, 43))
                                 }
                             }
@@ -2974,9 +2974,9 @@ module Harness {
                                 for (var pos = 0; pos < code.length; pos++) {
 >pos : Symbol(pos, Decl(parserharness.ts, 1009, 40))
 >pos : Symbol(pos, Decl(parserharness.ts, 1009, 40))
->code.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>code.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >code : Symbol(code, Decl(parserharness.ts, 957, 24))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >pos : Symbol(pos, Decl(parserharness.ts, 1009, 40))
 
                                     var tyInfo = compiler.pullGetTypeInfoAtPosition(pos, script2);
@@ -3004,9 +3004,9 @@ module Harness {
 >targetIdentifier : Symbol(targetIdentifier, Decl(parserharness.ts, 958, 19))
 
                                         if (!matchingIdentifiers.some(value => (value.identifier === foundValue.identifier) && (value.code === foundValue.code) && (value.type === foundValue.type))) {
->matchingIdentifiers.some : Symbol(Array.some, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->some : Symbol(Array.some, Decl(lib.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >value : Symbol(value, Decl(parserharness.ts, 1014, 70))
 >value.identifier : Symbol(Type.identifier, Decl(parserharness.ts, 804, 49))
 >value : Symbol(value, Decl(parserharness.ts, 1014, 70))
@@ -3028,9 +3028,9 @@ module Harness {
 >type : Symbol(Type.type, Decl(parserharness.ts, 804, 24))
 
                                             matchingIdentifiers.push(foundValue);
->matchingIdentifiers.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >foundValue : Symbol(foundValue, Decl(parserharness.ts, 1003, 35), Decl(parserharness.ts, 1013, 43))
                                         }
                                     }
@@ -3041,30 +3041,30 @@ module Harness {
                 }
 
                 if (matchingIdentifiers.length === 0) {
->matchingIdentifiers.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                     if (targetPosition > -1) {
 >targetPosition : Symbol(targetPosition, Decl(parserharness.ts, 959, 19))
 
                         throw new Error("Could not find an identifier at position " + targetPosition);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >targetPosition : Symbol(targetPosition, Decl(parserharness.ts, 959, 19))
                     }
                     else {
                         throw new Error("Could not find an identifier " + targetIdentifier + " in any known scopes");
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >targetIdentifier : Symbol(targetIdentifier, Decl(parserharness.ts, 958, 19))
                     }
                 }
                 else if (matchingIdentifiers.length > 1) {
->matchingIdentifiers.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>matchingIdentifiers.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >matchingIdentifiers : Symbol(matchingIdentifiers, Decl(parserharness.ts, 978, 19))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                     throw new Error("Found multiple matching identifiers for " + target);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >target : Symbol(target, Decl(parserharness.ts, 957, 37))
                 }
                 else {
@@ -3301,9 +3301,9 @@ module Harness {
 >outputs : Symbol(outputs, Decl(parserharness.ts, 1120, 19))
 
                     if (fn.indexOf('.d.ts') >= 0) {
->fn.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
+>fn.indexOf : Symbol(String.indexOf, Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(parserharness.ts, 1136, 24))
->indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
+>indexOf : Symbol(String.indexOf, Decl(lib.es5.d.ts, --, --))
 
                         var writer = <Harness.Compiler.WriterAggregator>outputs[fn];
 >writer : Symbol(writer, Decl(parserharness.ts, 1138, 27))
@@ -3320,18 +3320,18 @@ module Harness {
 
                         results = writer.lines.join('\n');
 >results : Symbol(results, Decl(parserharness.ts, 1135, 19))
->writer.lines.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>writer.lines.join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 >writer.lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
 >writer : Symbol(writer, Decl(parserharness.ts, 1138, 27))
 >lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
->join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 
                         if (verifyNoDeclFile && results != "") {
 >verifyNoDeclFile : Symbol(verifyNoDeclFile, Decl(parserharness.ts, 1106, 54))
 >results : Symbol(results, Decl(parserharness.ts, 1135, 19))
 
                             throw new Error('Compilation should not produce ' + fn);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(parserharness.ts, 1136, 24))
                         }
                     }
@@ -3348,7 +3348,7 @@ module Harness {
 >verifyNoDeclFile : Symbol(verifyNoDeclFile, Decl(parserharness.ts, 1106, 54))
 
                     throw new Error('Compilation did not produce .d.ts files');
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
                 }
             } finally {
                 compiler.settings.generateDeclarationFiles = false;
@@ -3410,14 +3410,14 @@ module Harness {
 >lines : Symbol(lines, Decl(parserharness.ts, 1176, 19))
 
                 fileResults.forEach(v => lines = lines.concat(v.file.lines));
->fileResults.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>fileResults.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >fileResults : Symbol(fileResults, Decl(parserharness.ts, 1175, 24))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >v : Symbol(v, Decl(parserharness.ts, 1177, 36))
 >lines : Symbol(lines, Decl(parserharness.ts, 1176, 19))
->lines.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>lines.concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >lines : Symbol(lines, Decl(parserharness.ts, 1176, 19))
->concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>concat : Symbol(Array.concat, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >v.file.lines : Symbol(WriterAggregator.lines, Decl(parserharness.ts, 690, 62))
 >v.file : Symbol(file, Decl(parserharness.ts, 1175, 63))
 >v : Symbol(v, Decl(parserharness.ts, 1177, 36))
@@ -3428,9 +3428,9 @@ module Harness {
 >this.code : Symbol(CompilerResult.code, Decl(parserharness.ts, 1170, 37))
 >this : Symbol(CompilerResult, Decl(parserharness.ts, 1167, 9))
 >code : Symbol(CompilerResult.code, Decl(parserharness.ts, 1170, 37))
->lines.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>lines.join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 >lines : Symbol(lines, Decl(parserharness.ts, 1176, 19))
->join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 
                 this.errors = [];
 >this.errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
@@ -3440,9 +3440,9 @@ module Harness {
                 for (var i = 0; i < errorLines.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 1182, 24))
 >i : Symbol(i, Decl(parserharness.ts, 1182, 24))
->errorLines.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>errorLines.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >errorLines : Symbol(errorLines, Decl(parserharness.ts, 1175, 92))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1182, 24))
 
                     if (Harness.usePull) {
@@ -3456,11 +3456,11 @@ module Harness {
 >i : Symbol(i, Decl(parserharness.ts, 1182, 24))
 
                         this.errors.push(new CompilerError(err.filename, 0, 0, err.message));
->this.errors.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.errors.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
 >this : Symbol(CompilerResult, Decl(parserharness.ts, 1167, 9))
 >errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >CompilerError : Symbol(CompilerError, Decl(parserharness.ts, 1206, 9))
 >err : Symbol(err, Decl(parserharness.ts, 1184, 27))
 >err : Symbol(err, Decl(parserharness.ts, 1184, 27))
@@ -3468,25 +3468,25 @@ module Harness {
                     } else {
                         var match = errorLines[i].match(/([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/);
 >match : Symbol(match, Decl(parserharness.ts, 1187, 27))
->errorLines[i].match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>errorLines[i].match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >errorLines : Symbol(errorLines, Decl(parserharness.ts, 1175, 92))
 >i : Symbol(i, Decl(parserharness.ts, 1182, 24))
->match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 
                         if (match) {
 >match : Symbol(match, Decl(parserharness.ts, 1187, 27))
 
                             this.errors.push(new CompilerError(match[1], parseFloat(match[2]), parseFloat(match[3]), match[4]));
->this.errors.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.errors.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
 >this : Symbol(CompilerResult, Decl(parserharness.ts, 1167, 9))
 >errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >CompilerError : Symbol(CompilerError, Decl(parserharness.ts, 1206, 9))
 >match : Symbol(match, Decl(parserharness.ts, 1187, 27))
->parseFloat : Symbol(parseFloat, Decl(lib.d.ts, --, --))
+>parseFloat : Symbol(parseFloat, Decl(lib.es5.d.ts, --, --))
 >match : Symbol(match, Decl(parserharness.ts, 1187, 27))
->parseFloat : Symbol(parseFloat, Decl(lib.d.ts, --, --))
+>parseFloat : Symbol(parseFloat, Decl(lib.es5.d.ts, --, --))
 >match : Symbol(match, Decl(parserharness.ts, 1187, 27))
 >match : Symbol(match, Decl(parserharness.ts, 1187, 27))
                         }
@@ -3508,11 +3508,11 @@ module Harness {
                 for (var i = 0; i < this.errors.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 1199, 24))
 >i : Symbol(i, Decl(parserharness.ts, 1199, 24))
->this.errors.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.errors.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
 >this : Symbol(CompilerResult, Decl(parserharness.ts, 1167, 9))
 >errors : Symbol(CompilerResult.errors, Decl(parserharness.ts, 1171, 32))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1199, 24))
 
                     if (this.errors[i].line === line && this.errors[i].column === column && this.errors[i].message === message)
@@ -3764,9 +3764,9 @@ module Harness {
 
             var filename = path.match(/[^\/]*$/)[0];
 >filename : Symbol(filename, Decl(parserharness.ts, 1287, 15))
->path.match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>path.match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >path : Symbol(path, Decl(parserharness.ts, 1285, 36))
->match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 
             var code = readFile(path);
 >code : Symbol(code, Decl(parserharness.ts, 1288, 15))
@@ -3888,27 +3888,27 @@ module Harness {
             var lastUnit = units[units.length - 1];
 >lastUnit : Symbol(lastUnit, Decl(parserharness.ts, 1326, 15))
 >units : Symbol(units, Decl(parserharness.ts, 1325, 37))
->units.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>units.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >units : Symbol(units, Decl(parserharness.ts, 1325, 37))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
             var unitName = switchToForwardSlashes(lastUnit.name).match(/[^\/]*$/)[0];
 >unitName : Symbol(unitName, Decl(parserharness.ts, 1327, 15))
->switchToForwardSlashes(lastUnit.name).match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>switchToForwardSlashes(lastUnit.name).match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >switchToForwardSlashes : Symbol(switchToForwardSlashes, Decl(parserharness.ts, 25, 22))
 >lastUnit.name : Symbol(TestCaseParser.TestUnitData.name, Decl(parserharness.ts, 1422, 28))
 >lastUnit : Symbol(lastUnit, Decl(parserharness.ts, 1326, 15))
 >name : Symbol(TestCaseParser.TestUnitData.name, Decl(parserharness.ts, 1422, 28))
->match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 
             var dependencies = units.slice(0, units.length - 1);
 >dependencies : Symbol(dependencies, Decl(parserharness.ts, 1329, 15))
->units.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>units.slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --))
 >units : Symbol(units, Decl(parserharness.ts, 1325, 37))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
->units.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --))
+>units.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >units : Symbol(units, Decl(parserharness.ts, 1325, 37))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
             var compilationContext = Harness.Compiler.defineCompilationContextForTest(unitName, dependencies);
 >compilationContext : Symbol(compilationContext, Decl(parserharness.ts, 1330, 15))
@@ -3999,9 +3999,9 @@ module Harness {
 >isDeclareFile : Symbol(isDeclareFile, Decl(parserharness.ts, 1352, 15))
 
             scripts.push(addUnit(code, uName, false, isDeclareFile, references));
->scripts.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>scripts.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >scripts : Symbol(scripts, Decl(parserharness.ts, 1344, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >addUnit : Symbol(addUnit, Decl(parserharness.ts, 1253, 9))
 >code : Symbol(code, Decl(parserharness.ts, 1343, 38))
 >uName : Symbol(uName, Decl(parserharness.ts, 1354, 15))
@@ -4077,9 +4077,9 @@ module Harness {
 
             // if the given file has no dependencies, there is no context to return, it can be compiled without additional work
             if (dependencies.length == 0) {
->dependencies.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>dependencies.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >dependencies : Symbol(dependencies, Decl(parserharness.ts, 1381, 73))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                 return null;
             } else {
@@ -4092,9 +4092,9 @@ module Harness {
                     // REVIEW: if any dependency has a triple slash reference then does postCompile potentially have to do a recreate since we can't update references with updateUnit?
                     // easy enough to do if so, prefer to avoid the recreate cost until it proves to be an issue
                     dependencies.forEach(dep => {
->dependencies.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>dependencies.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >dependencies : Symbol(dependencies, Decl(parserharness.ts, 1381, 73))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >dep : Symbol(dep, Decl(parserharness.ts, 1390, 41))
 
                         addUnit(dep.content, dep.name, false, Harness.Compiler.isDeclareFile(dep.name));
@@ -4115,9 +4115,9 @@ module Harness {
 >name : Symbol(TestCaseParser.TestUnitData.name, Decl(parserharness.ts, 1422, 28))
 
                         addedFiles.push(dep.name);
->addedFiles.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>addedFiles.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >addedFiles : Symbol(addedFiles, Decl(parserharness.ts, 1386, 19))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >dep.name : Symbol(TestCaseParser.TestUnitData.name, Decl(parserharness.ts, 1422, 28))
 >dep : Symbol(dep, Decl(parserharness.ts, 1390, 41))
 >name : Symbol(TestCaseParser.TestUnitData.name, Decl(parserharness.ts, 1422, 28))
@@ -4128,9 +4128,9 @@ module Harness {
 >postcompile : Symbol(postcompile, Decl(parserharness.ts, 1395, 19))
 
                     addedFiles.forEach(file => {
->addedFiles.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>addedFiles.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >addedFiles : Symbol(addedFiles, Decl(parserharness.ts, 1386, 19))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >file : Symbol(file, Decl(parserharness.ts, 1396, 39))
 
                         updateUnit('', file);
@@ -4218,9 +4218,9 @@ module Harness {
 >content : Symbol(content, Decl(parserharness.ts, 1434, 41))
 
                 opts.push({ flag: match[1], value: match[2] });
->opts.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>opts.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >opts : Symbol(opts, Decl(parserharness.ts, 1436, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >flag : Symbol(flag, Decl(parserharness.ts, 1440, 27))
 >match : Symbol(match, Decl(parserharness.ts, 1438, 15))
 >value : Symbol(value, Decl(parserharness.ts, 1440, 43))
@@ -4272,9 +4272,9 @@ module Harness {
             for (var i = 0; i < lines.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 1462, 20))
 >i : Symbol(i, Decl(parserharness.ts, 1462, 20))
->lines.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>lines.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >lines : Symbol(lines, Decl(parserharness.ts, 1454, 15))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1462, 20))
 
                 var line = lines[i];
@@ -4284,8 +4284,8 @@ module Harness {
 
                 var isTripleSlashReference = /[\/]{3}\s*<reference path/.test(line);
 >isTripleSlashReference : Symbol(isTripleSlashReference, Decl(parserharness.ts, 1464, 19))
->/[\/]{3}\s*<reference path/.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
->test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>/[\/]{3}\s*<reference path/.test : Symbol(RegExp.test, Decl(lib.es5.d.ts, --, --))
+>test : Symbol(RegExp.test, Decl(lib.es5.d.ts, --, --))
 >line : Symbol(line, Decl(parserharness.ts, 1463, 19))
 
                 var testMetaData = optionRegex.exec(line);
@@ -4298,9 +4298,9 @@ module Harness {
 
                     var isRef = line.match(/reference\spath='(\w*_?\w*\.?d?\.ts)'/);
 >isRef : Symbol(isRef, Decl(parserharness.ts, 1468, 23))
->line.match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>line.match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >line : Symbol(line, Decl(parserharness.ts, 1463, 19))
->match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 
                     if (isRef) {
 >isRef : Symbol(isRef, Decl(parserharness.ts, 1468, 23))
@@ -4330,9 +4330,9 @@ module Harness {
                         };
 
                         refs.push(ref);
->refs.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>refs.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >refs : Symbol(refs, Decl(parserharness.ts, 1460, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >ref : Symbol(ref, Decl(parserharness.ts, 1470, 27))
                     }
                 } else if (testMetaData) {
@@ -4342,20 +4342,20 @@ module Harness {
                     optionRegex.lastIndex = 0;
                     var fileNameIndex = fileMetadataNames.indexOf(testMetaData[1].toLowerCase());
 >fileNameIndex : Symbol(fileNameIndex, Decl(parserharness.ts, 1484, 23))
->fileMetadataNames.indexOf : Symbol(Array.indexOf, Decl(lib.d.ts, --, --))
+>fileMetadataNames.indexOf : Symbol(Array.indexOf, Decl(lib.es5.d.ts, --, --))
 >fileMetadataNames : Symbol(fileMetadataNames, Decl(parserharness.ts, 1432, 11))
->indexOf : Symbol(Array.indexOf, Decl(lib.d.ts, --, --))
+>indexOf : Symbol(Array.indexOf, Decl(lib.es5.d.ts, --, --))
 >testMetaData : Symbol(testMetaData, Decl(parserharness.ts, 1465, 19))
 
                     if (fileNameIndex == -1) {
 >fileNameIndex : Symbol(fileNameIndex, Decl(parserharness.ts, 1484, 23))
 
                         throw new Error('Unrecognized metadata name "' + testMetaData[1] + '". Available file metadata names are: ' + fileMetadataNames.join(', '));
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >testMetaData : Symbol(testMetaData, Decl(parserharness.ts, 1465, 19))
->fileMetadataNames.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>fileMetadataNames.join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 >fileMetadataNames : Symbol(fileMetadataNames, Decl(parserharness.ts, 1432, 11))
->join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>join : Symbol(Array.join, Decl(lib.es5.d.ts, --, --))
 
                     } else if (fileNameIndex == 0) {
 >fileNameIndex : Symbol(fileNameIndex, Decl(parserharness.ts, 1484, 23))
@@ -4399,9 +4399,9 @@ module Harness {
 
                             };
                         files.push(newTestFile);
->files.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>files.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >files : Symbol(files, Decl(parserharness.ts, 1452, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >newTestFile : Symbol(newTestFile, Decl(parserharness.ts, 1496, 27), Decl(parserharness.ts, 1532, 15))
 
                         // Reset local data
@@ -4449,9 +4449,9 @@ module Harness {
             // normalize the filename for the single file case
             currentFileName = files.length > 0 ? currentFileName : '0.ts';
 >currentFileName : Symbol(currentFileName, Decl(parserharness.ts, 1459, 15))
->files.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>files.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >files : Symbol(files, Decl(parserharness.ts, 1452, 15))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >currentFileName : Symbol(currentFileName, Decl(parserharness.ts, 1459, 15))
 
             // EOF, push whatever remains
@@ -4480,9 +4480,9 @@ module Harness {
 
             };
             files.push(newTestFile);
->files.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>files.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >files : Symbol(files, Decl(parserharness.ts, 1452, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >newTestFile : Symbol(newTestFile, Decl(parserharness.ts, 1496, 27), Decl(parserharness.ts, 1532, 15))
 
             return { settings: settings, testUnitData: files };
@@ -4553,11 +4553,11 @@ module Harness {
             // Apply edits
             var prefix = this.content.substring(0, minChar);
 >prefix : Symbol(prefix, Decl(parserharness.ts, 1562, 15))
->this.content.substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>this.content.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >this.content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
->substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >minChar : Symbol(minChar, Decl(parserharness.ts, 1560, 27))
 
             var middle = newText;
@@ -4566,11 +4566,11 @@ module Harness {
 
             var suffix = this.content.substring(limChar);
 >suffix : Symbol(suffix, Decl(parserharness.ts, 1564, 15))
->this.content.substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>this.content.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >this.content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
->substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >limChar : Symbol(limChar, Decl(parserharness.ts, 1560, 43))
 
             this.content = prefix + middle + suffix;
@@ -4583,19 +4583,19 @@ module Harness {
 
             // Store edit range + new length of script
             this.editRanges.push({
->this.editRanges.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.editRanges.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 
                 length: this.content.length,
 >length : Symbol(length, Decl(parserharness.ts, 1568, 34))
->this.content.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>this.content.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >this.content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 
                 editRange: new TypeScript.ScriptEditRange(minChar, limChar, (limChar - minChar) + newText.length)
 >editRange : Symbol(editRange, Decl(parserharness.ts, 1569, 44))
@@ -4603,36 +4603,36 @@ module Harness {
 >limChar : Symbol(limChar, Decl(parserharness.ts, 1560, 43))
 >limChar : Symbol(limChar, Decl(parserharness.ts, 1560, 43))
 >minChar : Symbol(minChar, Decl(parserharness.ts, 1560, 27))
->newText.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>newText.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >newText : Symbol(newText, Decl(parserharness.ts, 1560, 60))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 
             });
 
             if (this.editRanges.length > this.maxScriptVersions) {
->this.editRanges.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.editRanges.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.maxScriptVersions : Symbol(ScriptInfo.maxScriptVersions, Decl(parserharness.ts, 1549, 92))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >maxScriptVersions : Symbol(ScriptInfo.maxScriptVersions, Decl(parserharness.ts, 1549, 92))
 
                 this.editRanges.splice(0, this.maxScriptVersions - this.editRanges.length);
->this.editRanges.splice : Symbol(Array.splice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>this.editRanges.splice : Symbol(Array.splice, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->splice : Symbol(Array.splice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>splice : Symbol(Array.splice, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.maxScriptVersions : Symbol(ScriptInfo.maxScriptVersions, Decl(parserharness.ts, 1549, 92))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >maxScriptVersions : Symbol(ScriptInfo.maxScriptVersions, Decl(parserharness.ts, 1549, 92))
->this.editRanges.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.editRanges.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
             }
 
             // Update version #
@@ -4658,11 +4658,11 @@ module Harness {
 
             var initialEditRangeIndex = this.editRanges.length - (this.version - version);
 >initialEditRangeIndex : Symbol(initialEditRangeIndex, Decl(parserharness.ts, 1587, 15))
->this.editRanges.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.editRanges.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.version : Symbol(ScriptInfo.version, Decl(parserharness.ts, 1545, 29))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >version : Symbol(ScriptInfo.version, Decl(parserharness.ts, 1545, 29))
@@ -4671,11 +4671,11 @@ module Harness {
             if (initialEditRangeIndex < 0 || initialEditRangeIndex >= this.editRanges.length) {
 >initialEditRangeIndex : Symbol(initialEditRangeIndex, Decl(parserharness.ts, 1587, 15))
 >initialEditRangeIndex : Symbol(initialEditRangeIndex, Decl(parserharness.ts, 1587, 15))
->this.editRanges.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.editRanges.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                 // Too far away from what we know
                 return TypeScript.ScriptEditRange.unknown();
@@ -4683,38 +4683,38 @@ module Harness {
 
             var entries = this.editRanges.slice(initialEditRangeIndex);
 >entries : Symbol(entries, Decl(parserharness.ts, 1593, 15))
->this.editRanges.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>this.editRanges.slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --))
 >this.editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
 >this : Symbol(ScriptInfo, Decl(parserharness.ts, 1543, 5))
 >editRanges : Symbol(ScriptInfo.editRanges, Decl(parserharness.ts, 1546, 31))
->slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --))
 >initialEditRangeIndex : Symbol(initialEditRangeIndex, Decl(parserharness.ts, 1587, 15))
 
             var minDistFromStart = entries.map(x => x.editRange.minChar).reduce((prev, current) => Math.min(prev, current));
 >minDistFromStart : Symbol(minDistFromStart, Decl(parserharness.ts, 1595, 15))
->entries.map(x => x.editRange.minChar).reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->entries.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>entries.map(x => x.editRange.minChar).reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>entries.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >entries : Symbol(entries, Decl(parserharness.ts, 1593, 15))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(parserharness.ts, 1595, 47))
 >x.editRange : Symbol(editRange, Decl(parserharness.ts, 1547, 44))
 >x : Symbol(x, Decl(parserharness.ts, 1595, 47))
 >editRange : Symbol(editRange, Decl(parserharness.ts, 1547, 44))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >prev : Symbol(prev, Decl(parserharness.ts, 1595, 81))
 >current : Symbol(current, Decl(parserharness.ts, 1595, 86))
->Math.min : Symbol(Math.min, Decl(lib.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->min : Symbol(Math.min, Decl(lib.d.ts, --, --))
+>Math.min : Symbol(Math.min, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>min : Symbol(Math.min, Decl(lib.es5.d.ts, --, --))
 >prev : Symbol(prev, Decl(parserharness.ts, 1595, 81))
 >current : Symbol(current, Decl(parserharness.ts, 1595, 86))
 
             var minDistFromEnd = entries.map(x => x.length - x.editRange.limChar).reduce((prev, current) => Math.min(prev, current));
 >minDistFromEnd : Symbol(minDistFromEnd, Decl(parserharness.ts, 1596, 15))
->entries.map(x => x.length - x.editRange.limChar).reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->entries.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>entries.map(x => x.length - x.editRange.limChar).reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>entries.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >entries : Symbol(entries, Decl(parserharness.ts, 1593, 15))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(parserharness.ts, 1596, 45))
 >x.length : Symbol(length, Decl(parserharness.ts, 1547, 28))
 >x : Symbol(x, Decl(parserharness.ts, 1596, 45))
@@ -4722,26 +4722,26 @@ module Harness {
 >x.editRange : Symbol(editRange, Decl(parserharness.ts, 1547, 44))
 >x : Symbol(x, Decl(parserharness.ts, 1596, 45))
 >editRange : Symbol(editRange, Decl(parserharness.ts, 1547, 44))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >prev : Symbol(prev, Decl(parserharness.ts, 1596, 90))
 >current : Symbol(current, Decl(parserharness.ts, 1596, 95))
->Math.min : Symbol(Math.min, Decl(lib.d.ts, --, --))
->Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->min : Symbol(Math.min, Decl(lib.d.ts, --, --))
+>Math.min : Symbol(Math.min, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>min : Symbol(Math.min, Decl(lib.es5.d.ts, --, --))
 >prev : Symbol(prev, Decl(parserharness.ts, 1596, 90))
 >current : Symbol(current, Decl(parserharness.ts, 1596, 95))
 
             var aggDelta = entries.map(x => x.editRange.delta).reduce((prev, current) => prev + current);
 >aggDelta : Symbol(aggDelta, Decl(parserharness.ts, 1597, 15))
->entries.map(x => x.editRange.delta).reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->entries.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>entries.map(x => x.editRange.delta).reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>entries.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >entries : Symbol(entries, Decl(parserharness.ts, 1593, 15))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(parserharness.ts, 1597, 39))
 >x.editRange : Symbol(editRange, Decl(parserharness.ts, 1547, 44))
 >x : Symbol(x, Decl(parserharness.ts, 1597, 39))
 >editRange : Symbol(editRange, Decl(parserharness.ts, 1547, 44))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >prev : Symbol(prev, Decl(parserharness.ts, 1597, 71))
 >current : Symbol(current, Decl(parserharness.ts, 1597, 76))
 >prev : Symbol(prev, Decl(parserharness.ts, 1597, 71))
@@ -4820,11 +4820,11 @@ module Harness {
 >maxScriptVersions : Symbol(TypeScriptLS.maxScriptVersions, Decl(parserharness.ts, 1606, 42))
 
             this.scripts.push(script);
->this.scripts.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>this.scripts.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >this.scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >this : Symbol(TypeScriptLS, Decl(parserharness.ts, 1601, 5))
 >scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >script : Symbol(script, Decl(parserharness.ts, 1619, 15))
         }
 
@@ -4837,11 +4837,11 @@ module Harness {
             for (var i = 0; i < this.scripts.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 1624, 20))
 >i : Symbol(i, Decl(parserharness.ts, 1624, 20))
->this.scripts.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.scripts.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >this : Symbol(TypeScriptLS, Decl(parserharness.ts, 1601, 5))
 >scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1624, 20))
 
                 if (this.scripts[i].name == name) {
@@ -4886,11 +4886,11 @@ module Harness {
             for (var i = 0; i < this.scripts.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 1635, 20))
 >i : Symbol(i, Decl(parserharness.ts, 1635, 20))
->this.scripts.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.scripts.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >this : Symbol(TypeScriptLS, Decl(parserharness.ts, 1601, 5))
 >scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1635, 20))
 
                 if (this.scripts[i].name == name) {
@@ -4918,7 +4918,7 @@ module Harness {
             }
 
             throw new Error("No script with name '" + name + "'");
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >name : Symbol(name, Decl(parserharness.ts, 1634, 26))
         }
 
@@ -4975,11 +4975,11 @@ module Harness {
 >getScriptCount : Symbol(TypeScriptLS.getScriptCount, Decl(parserharness.ts, 1669, 9))
 
             return this.scripts.length;
->this.scripts.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>this.scripts.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >this.scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >this : Symbol(TypeScriptLS, Decl(parserharness.ts, 1601, 5))
 >scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
         }
 
         public getScriptSourceText(scriptIndex: number, start: number, end: number): string {
@@ -4989,14 +4989,14 @@ module Harness {
 >end : Symbol(end, Decl(parserharness.ts, 1675, 70))
 
             return this.scripts[scriptIndex].content.substring(start, end);
->this.scripts[scriptIndex].content.substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>this.scripts[scriptIndex].content.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >this.scripts[scriptIndex].content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
 >this.scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >this : Symbol(TypeScriptLS, Decl(parserharness.ts, 1601, 5))
 >scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >scriptIndex : Symbol(scriptIndex, Decl(parserharness.ts, 1675, 35))
 >content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
->substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >start : Symbol(start, Decl(parserharness.ts, 1675, 55))
 >end : Symbol(end, Decl(parserharness.ts, 1675, 70))
         }
@@ -5006,14 +5006,14 @@ module Harness {
 >scriptIndex : Symbol(scriptIndex, Decl(parserharness.ts, 1679, 37))
 
             return this.scripts[scriptIndex].content.length;
->this.scripts[scriptIndex].content.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>this.scripts[scriptIndex].content.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
 >this.scripts[scriptIndex].content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
 >this.scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >this : Symbol(TypeScriptLS, Decl(parserharness.ts, 1601, 5))
 >scripts : Symbol(TypeScriptLS.scripts, Decl(parserharness.ts, 1604, 57))
 >scriptIndex : Symbol(scriptIndex, Decl(parserharness.ts, 1679, 37))
 >content : Symbol(ScriptInfo.content, Decl(parserharness.ts, 1549, 40))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
         }
 
         public getScriptId(scriptIndex: number): string {
@@ -5283,9 +5283,9 @@ module Harness {
 
             for (var i = edits.length - 1; i >= 0; i--) {
 >i : Symbol(i, Decl(parserharness.ts, 1772, 20))
->edits.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>edits.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >edits : Symbol(edits, Decl(parserharness.ts, 1768, 42))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1772, 20))
 >i : Symbol(i, Decl(parserharness.ts, 1772, 20))
 
@@ -5296,9 +5296,9 @@ module Harness {
 
                 var prefix = result.substring(0, edit.minChar);
 >prefix : Symbol(prefix, Decl(parserharness.ts, 1774, 19))
->result.substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>result.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1769, 15))
->substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >edit : Symbol(edit, Decl(parserharness.ts, 1773, 19))
 
                 var middle = edit.text;
@@ -5307,9 +5307,9 @@ module Harness {
 
                 var suffix = result.substring(edit.limChar);
 >suffix : Symbol(suffix, Decl(parserharness.ts, 1776, 19))
->result.substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>result.substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1769, 15))
->substring : Symbol(String.substring, Decl(lib.d.ts, --, --))
+>substring : Symbol(String.substring, Decl(lib.es5.d.ts, --, --))
 >edit : Symbol(edit, Decl(parserharness.ts, 1773, 19))
 
                 result = prefix + middle + suffix;
@@ -5342,15 +5342,15 @@ module Harness {
                 for (var i = 0; i < edits.length; i++) {
 >i : Symbol(i, Decl(parserharness.ts, 1788, 24))
 >i : Symbol(i, Decl(parserharness.ts, 1788, 24))
->edits.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>edits.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >edits : Symbol(edits, Decl(parserharness.ts, 1786, 30))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >i : Symbol(i, Decl(parserharness.ts, 1788, 24))
 
                     result.push({ edit: edits[i], index: i });
->result.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1787, 19))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >edit : Symbol(edit, Decl(parserharness.ts, 1789, 33))
 >edits : Symbol(edits, Decl(parserharness.ts, 1786, 30))
 >i : Symbol(i, Decl(parserharness.ts, 1788, 24))
@@ -5363,10 +5363,10 @@ module Harness {
 
             var temp = mapEdits(edits).sort(function (a, b) {
 >temp : Symbol(temp, Decl(parserharness.ts, 1794, 15))
->mapEdits(edits).sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
+>mapEdits(edits).sort : Symbol(Array.sort, Decl(lib.es5.d.ts, --, --))
 >mapEdits : Symbol(mapEdits, Decl(parserharness.ts, 1784, 49))
 >edits : Symbol(edits, Decl(parserharness.ts, 1783, 31))
->sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
+>sort : Symbol(Array.sort, Decl(lib.es5.d.ts, --, --))
 >a : Symbol(a, Decl(parserharness.ts, 1794, 54))
 >b : Symbol(b, Decl(parserharness.ts, 1794, 56))
 
@@ -5404,9 +5404,9 @@ module Harness {
 
             while (current < temp.length) {
 >current : Symbol(current, Decl(parserharness.ts, 1801, 15))
->temp.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>temp.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >temp : Symbol(temp, Decl(parserharness.ts, 1794, 15))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                 var currentEdit = temp[current].edit;
 >currentEdit : Symbol(currentEdit, Decl(parserharness.ts, 1804, 19))
@@ -5418,14 +5418,14 @@ module Harness {
                 // Last edit
                 if (next >= temp.length) {
 >next : Symbol(next, Decl(parserharness.ts, 1802, 15))
->temp.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>temp.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >temp : Symbol(temp, Decl(parserharness.ts, 1794, 15))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
                     result.push(currentEdit);
->result.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1784, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >currentEdit : Symbol(currentEdit, Decl(parserharness.ts, 1804, 19))
 
                     current++;
@@ -5450,9 +5450,9 @@ module Harness {
 >gap : Symbol(gap, Decl(parserharness.ts, 1814, 19))
 
                     result.push(currentEdit);
->result.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>result.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1784, 15))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >currentEdit : Symbol(currentEdit, Decl(parserharness.ts, 1804, 19))
 
                     current = next;
@@ -5478,7 +5478,7 @@ module Harness {
                 }
                 else {
                     throw new Error("Trying to apply overlapping edits");
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
                 }
             }
 
@@ -5490,9 +5490,9 @@ module Harness {
 >getHostSettings : Symbol(TypeScriptLS.getHostSettings, Decl(parserharness.ts, 1836, 9))
 
             return JSON.stringify({ usePullLanguageService: usePull });
->JSON.stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->stringify : Symbol(JSON.stringify, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>JSON.stringify : Symbol(JSON.stringify, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>JSON : Symbol(JSON, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>stringify : Symbol(JSON.stringify, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >usePullLanguageService : Symbol(usePullLanguageService, Decl(parserharness.ts, 1839, 35))
 >usePull : Symbol(usePull, Decl(parserharness.ts, 58, 14))
         }
@@ -5511,18 +5511,18 @@ module Harness {
 >block : Symbol(block, Decl(parserharness.ts, 1844, 49))
 
         if (Runnable.currentStack.length === 0) {
->Runnable.currentStack.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 
             Runnable.currentStack.push(currentRun);
->Runnable.currentStack.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->push : Symbol(Array.push, Decl(lib.d.ts, --, --))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >currentRun : Symbol(currentRun, Decl(parserharness.ts, 2073, 7))
         }
 
@@ -5531,11 +5531,11 @@ module Harness {
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->Runnable.currentStack.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >addChild : Symbol(Runnable.addChild, Decl(parserharness.ts, 286, 41))
 >newScenario : Symbol(newScenario, Decl(parserharness.ts, 1845, 11))
     }
@@ -5555,11 +5555,11 @@ module Harness {
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->Runnable.currentStack.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>Runnable.currentStack.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >Runnable.currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
 >Runnable : Symbol(Runnable, Decl(parserharness.ts, 269, 5))
 >currentStack : Symbol(Runnable.currentStack, Decl(parserharness.ts, 271, 70))
->length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --))
 >addChild : Symbol(Runnable.addChild, Decl(parserharness.ts, 286, 41))
 >testCase : Symbol(testCase, Decl(parserharness.ts, 1854, 11))
     }
@@ -5599,7 +5599,7 @@ module Harness {
 >path : Symbol(path, Decl(parserharness.ts, 1869, 38))
 >callback : Symbol(callback, Decl(parserharness.ts, 1869, 51))
 >error : Symbol(error, Decl(parserharness.ts, 1869, 63))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1869, 76))
 
             path = switchToForwardSlashes(path);
@@ -5611,9 +5611,9 @@ module Harness {
 >runString : Symbol(runString, Decl(parserharness.ts, 1899, 9))
 >readFile : Symbol(readFile, Decl(parserharness.ts, 207, 5))
 >path : Symbol(path, Decl(parserharness.ts, 1869, 38))
->path.match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>path.match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >path : Symbol(path, Decl(parserharness.ts, 1869, 38))
->match : Symbol(String.match, Decl(lib.d.ts, --, --))
+>match : Symbol(String.match, Decl(lib.es5.d.ts, --, --))
 >callback : Symbol(callback, Decl(parserharness.ts, 1869, 51))
         }
 
@@ -5622,7 +5622,7 @@ module Harness {
 >code : Symbol(code, Decl(parserharness.ts, 1874, 36))
 >callback : Symbol(callback, Decl(parserharness.ts, 1874, 49))
 >error : Symbol(error, Decl(parserharness.ts, 1874, 61))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1874, 74))
 
             // List of names that get overriden by various test code we eval
@@ -5651,7 +5651,7 @@ module Harness {
             try {
                 var res = eval(code);
 >res : Symbol(res, Decl(parserharness.ts, 1885, 19))
->eval : Symbol(eval, Decl(lib.d.ts, --, --))
+>eval : Symbol(eval, Decl(lib.es5.d.ts, --, --))
 >code : Symbol(code, Decl(parserharness.ts, 1874, 36))
 
                 for (n in dangerNames) {
@@ -5699,7 +5699,7 @@ module Harness {
 >unitName : Symbol(unitName, Decl(parserharness.ts, 1901, 47))
 >callback : Symbol(callback, Decl(parserharness.ts, 1901, 65))
 >error : Symbol(error, Decl(parserharness.ts, 1901, 77))
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(parserharness.ts, 1901, 90))
 
             Compiler.compileString(code, unitName, function (res) {
@@ -5850,9 +5850,9 @@ module Harness {
 
                 reportContent = reportContent.replace(htmlTrailer, '');
 >reportContent : Symbol(reportContent, Decl(parserharness.ts, 1955, 15))
->reportContent.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reportContent.replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >reportContent : Symbol(reportContent, Decl(parserharness.ts, 1955, 15))
->replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >htmlTrailer : Symbol(htmlTrailer, Decl(parserharness.ts, 1913, 11))
 
             } else {
@@ -5900,7 +5900,7 @@ module Harness {
 >undefined : Symbol(undefined)
 
                 throw new Error('The generated content was "undefined". Return "null" if no baselining is required."');
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
             }
 
             // Store the content in the 'local' folder so we
@@ -5972,15 +5972,15 @@ module Harness {
 
                 expected = expected.replace(/\r\n?/g, '\n')
 >expected : Symbol(expected, Decl(parserharness.ts, 2005, 15))
->expected.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>expected.replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >expected : Symbol(expected, Decl(parserharness.ts, 2005, 15))
->replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
                 actual = actual.replace(/\r\n?/g, '\n')
 >actual : Symbol(actual, Decl(parserharness.ts, 1991, 35))
->actual.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>actual.replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >actual : Symbol(actual, Decl(parserharness.ts, 1991, 35))
->replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
             }
 
             return { expected: expected, actual: actual };
@@ -6051,7 +6051,7 @@ module Harness {
 >reportContentSoFar : Symbol(reportContentSoFar, Decl(parserharness.ts, 2034, 19))
 
                 throw new Error(errMsg);
->Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >errMsg : Symbol(errMsg, Decl(parserharness.ts, 2023, 19))
             }
         }
diff --git a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
index 67a62a2269c..eec311388c2 100644
--- a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
@@ -1,15 +1,3 @@
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(253,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(259,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(265,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(271,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(361,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(365,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(405,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(408,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(8,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(14,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(20,16): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
@@ -34,6 +22,18 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(368,20): error TS
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(371,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(377,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(379,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(253,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(259,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(265,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(271,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(361,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(365,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(405,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(408,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
 
 
 ==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (24 errors) ====
diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
index 23559cd9a3c..5bbc12d40b0 100644
--- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(19,77): error TS2449: Class 'publicClassInPrivateModule' used before its declaration.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(21,69): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(21,83): error TS2449: Class 'publicClassInPrivateModule' used before its declaration.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(63,55): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(68,65): error TS4020: 'extends' clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: 'extends' clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
 
 
 ==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (6 errors) ====
diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
index 586d4530c8e..4433ffa1628 100644
--- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(19,79): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(22,78): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(62,65): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(67,75): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
 
 
 ==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (5 errors) ====
diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
index 8367483ca97..25e07e73bbc 100644
--- a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
@@ -1,23 +1,3 @@
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(188,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(192,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(239,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(248,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(254,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(255,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(256,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(259,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(261,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(8,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
@@ -58,6 +38,26 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,71):
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(239,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(242,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(244,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(188,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(192,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(239,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(248,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(254,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(255,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(256,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(259,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(261,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
 
 
 ==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (40 errors) ====
diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
index 94c8b20311c..5c9e0a235bd 100644
--- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
@@ -1,25 +1,3 @@
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(281,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(282,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(283,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(284,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(309,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(315,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(321,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(327,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(416,63): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(428,21): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(441,78): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(447,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(448,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(449,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(450,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(453,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(456,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(459,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(462,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(466,70): error TS4060: Return type of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(469,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(472,85): error TS4060: Return type of exported function has or is using private name 'privateModule'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(8,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
@@ -64,6 +42,28 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(418,9):
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(422,70): error TS4060: Return type of exported function has or is using private name 'privateModule'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(425,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(428,85): error TS4060: Return type of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(281,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(282,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(283,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(284,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(309,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(315,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(321,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(327,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(416,63): error TS4060: Return type of exported function has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(428,21): error TS4060: Return type of exported function has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(441,78): error TS4060: Return type of exported function has or is using private name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(447,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(448,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(449,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(450,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(453,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(456,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(459,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(462,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(466,70): error TS4060: Return type of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(469,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(472,85): error TS4060: Return type of exported function has or is using private name 'privateModule'.
 
 
 ==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (44 errors) ====
diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
index 0669d3c3d26..e31227b5f8a 100644
--- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(19,84): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(22,83): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(62,70): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(67,80): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82): error TS4022: 'extends' clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
 
 
 ==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (5 errors) ====
diff --git a/tests/baselines/reference/privacyVarDeclFile.errors.txt b/tests/baselines/reference/privacyVarDeclFile.errors.txt
index c6ee30d6630..7f34767683a 100644
--- a/tests/baselines/reference/privacyVarDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyVarDeclFile.errors.txt
@@ -1,13 +1,3 @@
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(105,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(121,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(123,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(148,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(153,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(159,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(162,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(163,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(165,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(166,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(8,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(24,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(26,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
@@ -28,6 +18,16 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(146,40): error TS4028:
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(149,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(105,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(121,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(123,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(148,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(153,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(159,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(162,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(163,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(165,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(166,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
 
 
 ==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (20 errors) ====
diff --git a/tests/baselines/reference/promiseType.symbols b/tests/baselines/reference/promiseType.symbols
index 5eea680f9fb..c1227c10353 100644
--- a/tests/baselines/reference/promiseType.symbols
+++ b/tests/baselines/reference/promiseType.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/promiseType.ts ===
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare var x: any;
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
@@ -73,7 +73,7 @@ async function E() {
 >e : Symbol(e, Decl(promiseType.ts, 37, 11))
 
         throw Error();
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -91,10 +91,10 @@ async function F() {
 >e : Symbol(e, Decl(promiseType.ts, 47, 11))
 
         return Promise.reject(Error());
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -131,7 +131,7 @@ async function H() {
 >e : Symbol(e, Decl(promiseType.ts, 67, 11))
 
         throw Error();
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -150,10 +150,10 @@ async function I() {
 >e : Symbol(e, Decl(promiseType.ts, 77, 11))
 
         return Promise.reject(Error());
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -161,931 +161,931 @@ async function I() {
 
 const p00 = p.catch();
 >p00 : Symbol(p00, Decl(promiseType.ts, 84, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p01 = p.then();
 >p01 : Symbol(p01, Decl(promiseType.ts, 85, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p10 = p.catch(undefined);
 >p10 : Symbol(p10, Decl(promiseType.ts, 87, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p11 = p.catch(null);
 >p11 : Symbol(p11, Decl(promiseType.ts, 88, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p12 = p.catch(() => 1);
 >p12 : Symbol(p12, Decl(promiseType.ts, 89, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p13 = p.catch(() => x);
 >p13 : Symbol(p13, Decl(promiseType.ts, 90, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p14 = p.catch(() => undefined);
 >p14 : Symbol(p14, Decl(promiseType.ts, 91, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p15 = p.catch(() => null);
 >p15 : Symbol(p15, Decl(promiseType.ts, 92, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p16 = p.catch(() => {});
 >p16 : Symbol(p16, Decl(promiseType.ts, 93, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p17 = p.catch(() => {throw 1});
 >p17 : Symbol(p17, Decl(promiseType.ts, 94, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p18 = p.catch(() => Promise.reject(1));
 >p18 : Symbol(p18, Decl(promiseType.ts, 95, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p19 = p.catch(() => Promise.resolve(1));
 >p19 : Symbol(p19, Decl(promiseType.ts, 96, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p20 = p.then(undefined);
 >p20 : Symbol(p20, Decl(promiseType.ts, 98, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p21 = p.then(null);
 >p21 : Symbol(p21, Decl(promiseType.ts, 99, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p22 = p.then(() => 1);
 >p22 : Symbol(p22, Decl(promiseType.ts, 100, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p23 = p.then(() => x);
 >p23 : Symbol(p23, Decl(promiseType.ts, 101, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p24 = p.then(() => undefined);
 >p24 : Symbol(p24, Decl(promiseType.ts, 102, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p25 = p.then(() => null);
 >p25 : Symbol(p25, Decl(promiseType.ts, 103, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p26 = p.then(() => {});
 >p26 : Symbol(p26, Decl(promiseType.ts, 104, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p27 = p.then(() => {throw 1});
 >p27 : Symbol(p27, Decl(promiseType.ts, 105, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p28 = p.then(() => Promise.resolve(1));
 >p28 : Symbol(p28, Decl(promiseType.ts, 106, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Symbol(p29, Decl(promiseType.ts, 107, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p30 = p.then(undefined, undefined);
 >p30 : Symbol(p30, Decl(promiseType.ts, 109, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p31 = p.then(undefined, null);
 >p31 : Symbol(p31, Decl(promiseType.ts, 110, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p32 = p.then(undefined, () => 1);
 >p32 : Symbol(p32, Decl(promiseType.ts, 111, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p33 = p.then(undefined, () => x);
 >p33 : Symbol(p33, Decl(promiseType.ts, 112, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p34 = p.then(undefined, () => undefined);
 >p34 : Symbol(p34, Decl(promiseType.ts, 113, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p35 = p.then(undefined, () => null);
 >p35 : Symbol(p35, Decl(promiseType.ts, 114, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p36 = p.then(undefined, () => {});
 >p36 : Symbol(p36, Decl(promiseType.ts, 115, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p37 = p.then(undefined, () => {throw 1});
 >p37 : Symbol(p37, Decl(promiseType.ts, 116, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p38 = p.then(undefined, () => Promise.resolve(1));
 >p38 : Symbol(p38, Decl(promiseType.ts, 117, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Symbol(p39, Decl(promiseType.ts, 118, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p40 = p.then(null, undefined);
 >p40 : Symbol(p40, Decl(promiseType.ts, 120, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p41 = p.then(null, null);
 >p41 : Symbol(p41, Decl(promiseType.ts, 121, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p42 = p.then(null, () => 1);
 >p42 : Symbol(p42, Decl(promiseType.ts, 122, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p43 = p.then(null, () => x);
 >p43 : Symbol(p43, Decl(promiseType.ts, 123, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p44 = p.then(null, () => undefined);
 >p44 : Symbol(p44, Decl(promiseType.ts, 124, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p45 = p.then(null, () => null);
 >p45 : Symbol(p45, Decl(promiseType.ts, 125, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p46 = p.then(null, () => {});
 >p46 : Symbol(p46, Decl(promiseType.ts, 126, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p47 = p.then(null, () => {throw 1});
 >p47 : Symbol(p47, Decl(promiseType.ts, 127, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p48 = p.then(null, () => Promise.resolve(1));
 >p48 : Symbol(p48, Decl(promiseType.ts, 128, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Symbol(p49, Decl(promiseType.ts, 129, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p50 = p.then(() => "1", undefined);
 >p50 : Symbol(p50, Decl(promiseType.ts, 131, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p51 = p.then(() => "1", null);
 >p51 : Symbol(p51, Decl(promiseType.ts, 132, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p52 = p.then(() => "1", () => 1);
 >p52 : Symbol(p52, Decl(promiseType.ts, 133, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p53 = p.then(() => "1", () => x);
 >p53 : Symbol(p53, Decl(promiseType.ts, 134, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p54 = p.then(() => "1", () => undefined);
 >p54 : Symbol(p54, Decl(promiseType.ts, 135, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p55 = p.then(() => "1", () => null);
 >p55 : Symbol(p55, Decl(promiseType.ts, 136, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p56 = p.then(() => "1", () => {});
 >p56 : Symbol(p56, Decl(promiseType.ts, 137, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p57 = p.then(() => "1", () => {throw 1});
 >p57 : Symbol(p57, Decl(promiseType.ts, 138, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p58 : Symbol(p58, Decl(promiseType.ts, 139, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Symbol(p59, Decl(promiseType.ts, 140, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p60 = p.then(() => x, undefined);
 >p60 : Symbol(p60, Decl(promiseType.ts, 142, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 >undefined : Symbol(undefined)
 
 const p61 = p.then(() => x, null);
 >p61 : Symbol(p61, Decl(promiseType.ts, 143, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p62 = p.then(() => x, () => 1);
 >p62 : Symbol(p62, Decl(promiseType.ts, 144, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p63 = p.then(() => x, () => x);
 >p63 : Symbol(p63, Decl(promiseType.ts, 145, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p64 = p.then(() => x, () => undefined);
 >p64 : Symbol(p64, Decl(promiseType.ts, 146, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 >undefined : Symbol(undefined)
 
 const p65 = p.then(() => x, () => null);
 >p65 : Symbol(p65, Decl(promiseType.ts, 147, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p66 = p.then(() => x, () => {});
 >p66 : Symbol(p66, Decl(promiseType.ts, 148, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p67 = p.then(() => x, () => {throw 1});
 >p67 : Symbol(p67, Decl(promiseType.ts, 149, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p68 = p.then(() => x, () => Promise.resolve(1));
 >p68 : Symbol(p68, Decl(promiseType.ts, 150, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Symbol(p69, Decl(promiseType.ts, 151, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p70 = p.then(() => undefined, undefined);
 >p70 : Symbol(p70, Decl(promiseType.ts, 153, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p71 = p.then(() => undefined, null);
 >p71 : Symbol(p71, Decl(promiseType.ts, 154, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p72 = p.then(() => undefined, () => 1);
 >p72 : Symbol(p72, Decl(promiseType.ts, 155, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p73 = p.then(() => undefined, () => x);
 >p73 : Symbol(p73, Decl(promiseType.ts, 156, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p74 = p.then(() => undefined, () => undefined);
 >p74 : Symbol(p74, Decl(promiseType.ts, 157, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p75 = p.then(() => undefined, () => null);
 >p75 : Symbol(p75, Decl(promiseType.ts, 158, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p76 = p.then(() => undefined, () => {});
 >p76 : Symbol(p76, Decl(promiseType.ts, 159, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p77 = p.then(() => undefined, () => {throw 1});
 >p77 : Symbol(p77, Decl(promiseType.ts, 160, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p78 : Symbol(p78, Decl(promiseType.ts, 161, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Symbol(p79, Decl(promiseType.ts, 162, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p80 = p.then(() => null, undefined);
 >p80 : Symbol(p80, Decl(promiseType.ts, 164, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p81 = p.then(() => null, null);
 >p81 : Symbol(p81, Decl(promiseType.ts, 165, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p82 = p.then(() => null, () => 1);
 >p82 : Symbol(p82, Decl(promiseType.ts, 166, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p83 = p.then(() => null, () => x);
 >p83 : Symbol(p83, Decl(promiseType.ts, 167, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p84 = p.then(() => null, () => undefined);
 >p84 : Symbol(p84, Decl(promiseType.ts, 168, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p85 = p.then(() => null, () => null);
 >p85 : Symbol(p85, Decl(promiseType.ts, 169, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p86 = p.then(() => null, () => {});
 >p86 : Symbol(p86, Decl(promiseType.ts, 170, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p87 = p.then(() => null, () => {throw 1});
 >p87 : Symbol(p87, Decl(promiseType.ts, 171, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p88 = p.then(() => null, () => Promise.resolve(1));
 >p88 : Symbol(p88, Decl(promiseType.ts, 172, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Symbol(p89, Decl(promiseType.ts, 173, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p90 = p.then(() => {}, undefined);
 >p90 : Symbol(p90, Decl(promiseType.ts, 175, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p91 = p.then(() => {}, null);
 >p91 : Symbol(p91, Decl(promiseType.ts, 176, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p92 = p.then(() => {}, () => 1);
 >p92 : Symbol(p92, Decl(promiseType.ts, 177, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p93 = p.then(() => {}, () => x);
 >p93 : Symbol(p93, Decl(promiseType.ts, 178, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const p94 = p.then(() => {}, () => undefined);
 >p94 : Symbol(p94, Decl(promiseType.ts, 179, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p95 = p.then(() => {}, () => null);
 >p95 : Symbol(p95, Decl(promiseType.ts, 180, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p96 = p.then(() => {}, () => {});
 >p96 : Symbol(p96, Decl(promiseType.ts, 181, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p97 = p.then(() => {}, () => {throw 1});
 >p97 : Symbol(p97, Decl(promiseType.ts, 182, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p98 : Symbol(p98, Decl(promiseType.ts, 183, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Symbol(p99, Decl(promiseType.ts, 184, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pa0 = p.then(() => {throw 1}, undefined);
 >pa0 : Symbol(pa0, Decl(promiseType.ts, 186, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pa1 = p.then(() => {throw 1}, null);
 >pa1 : Symbol(pa1, Decl(promiseType.ts, 187, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa2 = p.then(() => {throw 1}, () => 1);
 >pa2 : Symbol(pa2, Decl(promiseType.ts, 188, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa3 = p.then(() => {throw 1}, () => x);
 >pa3 : Symbol(pa3, Decl(promiseType.ts, 189, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const pa4 = p.then(() => {throw 1}, () => undefined);
 >pa4 : Symbol(pa4, Decl(promiseType.ts, 190, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pa5 = p.then(() => {throw 1}, () => null);
 >pa5 : Symbol(pa5, Decl(promiseType.ts, 191, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa6 = p.then(() => {throw 1}, () => {});
 >pa6 : Symbol(pa6, Decl(promiseType.ts, 192, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >pa7 : Symbol(pa7, Decl(promiseType.ts, 193, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >pa8 : Symbol(pa8, Decl(promiseType.ts, 194, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Symbol(pa9, Decl(promiseType.ts, 195, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >pb0 : Symbol(pb0, Decl(promiseType.ts, 197, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
 >pb1 : Symbol(pb1, Decl(promiseType.ts, 198, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Symbol(pb2, Decl(promiseType.ts, 199, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Symbol(pb3, Decl(promiseType.ts, 200, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >pb4 : Symbol(pb4, Decl(promiseType.ts, 201, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >pb5 : Symbol(pb5, Decl(promiseType.ts, 202, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Symbol(pb6, Decl(promiseType.ts, 203, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Symbol(pb7, Decl(promiseType.ts, 204, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Symbol(pb8, Decl(promiseType.ts, 205, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Symbol(pb9, Decl(promiseType.ts, 206, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc0 = p.then(() => Promise.reject("1"), undefined);
 >pc0 : Symbol(pc0, Decl(promiseType.ts, 208, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pc1 = p.then(() => Promise.reject("1"), null);
 >pc1 : Symbol(pc1, Decl(promiseType.ts, 209, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >pc2 : Symbol(pc2, Decl(promiseType.ts, 210, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc3 = p.then(() => Promise.reject("1"), () => x);
 >pc3 : Symbol(pc3, Decl(promiseType.ts, 211, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >pc4 : Symbol(pc4, Decl(promiseType.ts, 212, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pc5 = p.then(() => Promise.reject("1"), () => null);
 >pc5 : Symbol(pc5, Decl(promiseType.ts, 213, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc6 = p.then(() => Promise.reject("1"), () => {});
 >pc6 : Symbol(pc6, Decl(promiseType.ts, 214, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >pc7 : Symbol(pc7, Decl(promiseType.ts, 215, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >pc8 : Symbol(pc8, Decl(promiseType.ts, 216, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Symbol(pc9, Decl(promiseType.ts, 217, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/promiseTypeStrictNull.symbols b/tests/baselines/reference/promiseTypeStrictNull.symbols
index 3fabb7f16b7..b9910bbae71 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.symbols
+++ b/tests/baselines/reference/promiseTypeStrictNull.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/promiseTypeStrictNull.ts ===
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 declare var x: any;
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
@@ -73,7 +73,7 @@ async function E() {
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 37, 11))
 
         throw Error();
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -91,10 +91,10 @@ async function F() {
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 47, 11))
 
         return Promise.reject(Error());
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -131,7 +131,7 @@ async function H() {
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 67, 11))
 
         throw Error();
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -150,10 +150,10 @@ async function I() {
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 77, 11))
 
         return Promise.reject(Error());
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     }
 }
 
@@ -161,931 +161,931 @@ async function I() {
 
 const p00 = p.catch();
 >p00 : Symbol(p00, Decl(promiseTypeStrictNull.ts, 84, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p01 = p.then();
 >p01 : Symbol(p01, Decl(promiseTypeStrictNull.ts, 85, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p10 = p.catch(undefined);
 >p10 : Symbol(p10, Decl(promiseTypeStrictNull.ts, 87, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p11 = p.catch(null);
 >p11 : Symbol(p11, Decl(promiseTypeStrictNull.ts, 88, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p12 = p.catch(() => 1);
 >p12 : Symbol(p12, Decl(promiseTypeStrictNull.ts, 89, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p13 = p.catch(() => x);
 >p13 : Symbol(p13, Decl(promiseTypeStrictNull.ts, 90, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p14 = p.catch(() => undefined);
 >p14 : Symbol(p14, Decl(promiseTypeStrictNull.ts, 91, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p15 = p.catch(() => null);
 >p15 : Symbol(p15, Decl(promiseTypeStrictNull.ts, 92, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p16 = p.catch(() => {});
 >p16 : Symbol(p16, Decl(promiseTypeStrictNull.ts, 93, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p17 = p.catch(() => {throw 1});
 >p17 : Symbol(p17, Decl(promiseTypeStrictNull.ts, 94, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 
 const p18 = p.catch(() => Promise.reject(1));
 >p18 : Symbol(p18, Decl(promiseTypeStrictNull.ts, 95, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p19 = p.catch(() => Promise.resolve(1));
 >p19 : Symbol(p19, Decl(promiseTypeStrictNull.ts, 96, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p20 = p.then(undefined);
 >p20 : Symbol(p20, Decl(promiseTypeStrictNull.ts, 98, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p21 = p.then(null);
 >p21 : Symbol(p21, Decl(promiseTypeStrictNull.ts, 99, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p22 = p.then(() => 1);
 >p22 : Symbol(p22, Decl(promiseTypeStrictNull.ts, 100, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p23 = p.then(() => x);
 >p23 : Symbol(p23, Decl(promiseTypeStrictNull.ts, 101, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p24 = p.then(() => undefined);
 >p24 : Symbol(p24, Decl(promiseTypeStrictNull.ts, 102, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p25 = p.then(() => null);
 >p25 : Symbol(p25, Decl(promiseTypeStrictNull.ts, 103, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p26 = p.then(() => {});
 >p26 : Symbol(p26, Decl(promiseTypeStrictNull.ts, 104, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p27 = p.then(() => {throw 1});
 >p27 : Symbol(p27, Decl(promiseTypeStrictNull.ts, 105, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p28 = p.then(() => Promise.resolve(1));
 >p28 : Symbol(p28, Decl(promiseTypeStrictNull.ts, 106, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Symbol(p29, Decl(promiseTypeStrictNull.ts, 107, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p30 = p.then(undefined, undefined);
 >p30 : Symbol(p30, Decl(promiseTypeStrictNull.ts, 109, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p31 = p.then(undefined, null);
 >p31 : Symbol(p31, Decl(promiseTypeStrictNull.ts, 110, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p32 = p.then(undefined, () => 1);
 >p32 : Symbol(p32, Decl(promiseTypeStrictNull.ts, 111, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p33 = p.then(undefined, () => x);
 >p33 : Symbol(p33, Decl(promiseTypeStrictNull.ts, 112, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p34 = p.then(undefined, () => undefined);
 >p34 : Symbol(p34, Decl(promiseTypeStrictNull.ts, 113, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p35 = p.then(undefined, () => null);
 >p35 : Symbol(p35, Decl(promiseTypeStrictNull.ts, 114, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p36 = p.then(undefined, () => {});
 >p36 : Symbol(p36, Decl(promiseTypeStrictNull.ts, 115, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p37 = p.then(undefined, () => {throw 1});
 >p37 : Symbol(p37, Decl(promiseTypeStrictNull.ts, 116, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p38 = p.then(undefined, () => Promise.resolve(1));
 >p38 : Symbol(p38, Decl(promiseTypeStrictNull.ts, 117, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Symbol(p39, Decl(promiseTypeStrictNull.ts, 118, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p40 = p.then(null, undefined);
 >p40 : Symbol(p40, Decl(promiseTypeStrictNull.ts, 120, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p41 = p.then(null, null);
 >p41 : Symbol(p41, Decl(promiseTypeStrictNull.ts, 121, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p42 = p.then(null, () => 1);
 >p42 : Symbol(p42, Decl(promiseTypeStrictNull.ts, 122, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p43 = p.then(null, () => x);
 >p43 : Symbol(p43, Decl(promiseTypeStrictNull.ts, 123, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p44 = p.then(null, () => undefined);
 >p44 : Symbol(p44, Decl(promiseTypeStrictNull.ts, 124, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p45 = p.then(null, () => null);
 >p45 : Symbol(p45, Decl(promiseTypeStrictNull.ts, 125, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p46 = p.then(null, () => {});
 >p46 : Symbol(p46, Decl(promiseTypeStrictNull.ts, 126, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p47 = p.then(null, () => {throw 1});
 >p47 : Symbol(p47, Decl(promiseTypeStrictNull.ts, 127, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p48 = p.then(null, () => Promise.resolve(1));
 >p48 : Symbol(p48, Decl(promiseTypeStrictNull.ts, 128, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Symbol(p49, Decl(promiseTypeStrictNull.ts, 129, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p50 = p.then(() => "1", undefined);
 >p50 : Symbol(p50, Decl(promiseTypeStrictNull.ts, 131, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p51 = p.then(() => "1", null);
 >p51 : Symbol(p51, Decl(promiseTypeStrictNull.ts, 132, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p52 = p.then(() => "1", () => 1);
 >p52 : Symbol(p52, Decl(promiseTypeStrictNull.ts, 133, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p53 = p.then(() => "1", () => x);
 >p53 : Symbol(p53, Decl(promiseTypeStrictNull.ts, 134, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p54 = p.then(() => "1", () => undefined);
 >p54 : Symbol(p54, Decl(promiseTypeStrictNull.ts, 135, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p55 = p.then(() => "1", () => null);
 >p55 : Symbol(p55, Decl(promiseTypeStrictNull.ts, 136, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p56 = p.then(() => "1", () => {});
 >p56 : Symbol(p56, Decl(promiseTypeStrictNull.ts, 137, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p57 = p.then(() => "1", () => {throw 1});
 >p57 : Symbol(p57, Decl(promiseTypeStrictNull.ts, 138, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p58 : Symbol(p58, Decl(promiseTypeStrictNull.ts, 139, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Symbol(p59, Decl(promiseTypeStrictNull.ts, 140, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p60 = p.then(() => x, undefined);
 >p60 : Symbol(p60, Decl(promiseTypeStrictNull.ts, 142, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 >undefined : Symbol(undefined)
 
 const p61 = p.then(() => x, null);
 >p61 : Symbol(p61, Decl(promiseTypeStrictNull.ts, 143, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p62 = p.then(() => x, () => 1);
 >p62 : Symbol(p62, Decl(promiseTypeStrictNull.ts, 144, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p63 = p.then(() => x, () => x);
 >p63 : Symbol(p63, Decl(promiseTypeStrictNull.ts, 145, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p64 = p.then(() => x, () => undefined);
 >p64 : Symbol(p64, Decl(promiseTypeStrictNull.ts, 146, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 >undefined : Symbol(undefined)
 
 const p65 = p.then(() => x, () => null);
 >p65 : Symbol(p65, Decl(promiseTypeStrictNull.ts, 147, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p66 = p.then(() => x, () => {});
 >p66 : Symbol(p66, Decl(promiseTypeStrictNull.ts, 148, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p67 = p.then(() => x, () => {throw 1});
 >p67 : Symbol(p67, Decl(promiseTypeStrictNull.ts, 149, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p68 = p.then(() => x, () => Promise.resolve(1));
 >p68 : Symbol(p68, Decl(promiseTypeStrictNull.ts, 150, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Symbol(p69, Decl(promiseTypeStrictNull.ts, 151, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p70 = p.then(() => undefined, undefined);
 >p70 : Symbol(p70, Decl(promiseTypeStrictNull.ts, 153, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p71 = p.then(() => undefined, null);
 >p71 : Symbol(p71, Decl(promiseTypeStrictNull.ts, 154, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p72 = p.then(() => undefined, () => 1);
 >p72 : Symbol(p72, Decl(promiseTypeStrictNull.ts, 155, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p73 = p.then(() => undefined, () => x);
 >p73 : Symbol(p73, Decl(promiseTypeStrictNull.ts, 156, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p74 = p.then(() => undefined, () => undefined);
 >p74 : Symbol(p74, Decl(promiseTypeStrictNull.ts, 157, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p75 = p.then(() => undefined, () => null);
 >p75 : Symbol(p75, Decl(promiseTypeStrictNull.ts, 158, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p76 = p.then(() => undefined, () => {});
 >p76 : Symbol(p76, Decl(promiseTypeStrictNull.ts, 159, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p77 = p.then(() => undefined, () => {throw 1});
 >p77 : Symbol(p77, Decl(promiseTypeStrictNull.ts, 160, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p78 : Symbol(p78, Decl(promiseTypeStrictNull.ts, 161, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Symbol(p79, Decl(promiseTypeStrictNull.ts, 162, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p80 = p.then(() => null, undefined);
 >p80 : Symbol(p80, Decl(promiseTypeStrictNull.ts, 164, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p81 = p.then(() => null, null);
 >p81 : Symbol(p81, Decl(promiseTypeStrictNull.ts, 165, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p82 = p.then(() => null, () => 1);
 >p82 : Symbol(p82, Decl(promiseTypeStrictNull.ts, 166, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p83 = p.then(() => null, () => x);
 >p83 : Symbol(p83, Decl(promiseTypeStrictNull.ts, 167, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p84 = p.then(() => null, () => undefined);
 >p84 : Symbol(p84, Decl(promiseTypeStrictNull.ts, 168, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p85 = p.then(() => null, () => null);
 >p85 : Symbol(p85, Decl(promiseTypeStrictNull.ts, 169, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p86 = p.then(() => null, () => {});
 >p86 : Symbol(p86, Decl(promiseTypeStrictNull.ts, 170, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p87 = p.then(() => null, () => {throw 1});
 >p87 : Symbol(p87, Decl(promiseTypeStrictNull.ts, 171, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p88 = p.then(() => null, () => Promise.resolve(1));
 >p88 : Symbol(p88, Decl(promiseTypeStrictNull.ts, 172, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Symbol(p89, Decl(promiseTypeStrictNull.ts, 173, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p90 = p.then(() => {}, undefined);
 >p90 : Symbol(p90, Decl(promiseTypeStrictNull.ts, 175, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p91 = p.then(() => {}, null);
 >p91 : Symbol(p91, Decl(promiseTypeStrictNull.ts, 176, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p92 = p.then(() => {}, () => 1);
 >p92 : Symbol(p92, Decl(promiseTypeStrictNull.ts, 177, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p93 = p.then(() => {}, () => x);
 >p93 : Symbol(p93, Decl(promiseTypeStrictNull.ts, 178, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const p94 = p.then(() => {}, () => undefined);
 >p94 : Symbol(p94, Decl(promiseTypeStrictNull.ts, 179, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p95 = p.then(() => {}, () => null);
 >p95 : Symbol(p95, Decl(promiseTypeStrictNull.ts, 180, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p96 = p.then(() => {}, () => {});
 >p96 : Symbol(p96, Decl(promiseTypeStrictNull.ts, 181, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p97 = p.then(() => {}, () => {throw 1});
 >p97 : Symbol(p97, Decl(promiseTypeStrictNull.ts, 182, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p98 : Symbol(p98, Decl(promiseTypeStrictNull.ts, 183, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Symbol(p99, Decl(promiseTypeStrictNull.ts, 184, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pa0 = p.then(() => {throw 1}, undefined);
 >pa0 : Symbol(pa0, Decl(promiseTypeStrictNull.ts, 186, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pa1 = p.then(() => {throw 1}, null);
 >pa1 : Symbol(pa1, Decl(promiseTypeStrictNull.ts, 187, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa2 = p.then(() => {throw 1}, () => 1);
 >pa2 : Symbol(pa2, Decl(promiseTypeStrictNull.ts, 188, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa3 = p.then(() => {throw 1}, () => x);
 >pa3 : Symbol(pa3, Decl(promiseTypeStrictNull.ts, 189, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const pa4 = p.then(() => {throw 1}, () => undefined);
 >pa4 : Symbol(pa4, Decl(promiseTypeStrictNull.ts, 190, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pa5 = p.then(() => {throw 1}, () => null);
 >pa5 : Symbol(pa5, Decl(promiseTypeStrictNull.ts, 191, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa6 = p.then(() => {throw 1}, () => {});
 >pa6 : Symbol(pa6, Decl(promiseTypeStrictNull.ts, 192, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >pa7 : Symbol(pa7, Decl(promiseTypeStrictNull.ts, 193, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 
 const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >pa8 : Symbol(pa8, Decl(promiseTypeStrictNull.ts, 194, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Symbol(pa9, Decl(promiseTypeStrictNull.ts, 195, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >pb0 : Symbol(pb0, Decl(promiseTypeStrictNull.ts, 197, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
 >pb1 : Symbol(pb1, Decl(promiseTypeStrictNull.ts, 198, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Symbol(pb2, Decl(promiseTypeStrictNull.ts, 199, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Symbol(pb3, Decl(promiseTypeStrictNull.ts, 200, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >pb4 : Symbol(pb4, Decl(promiseTypeStrictNull.ts, 201, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >pb5 : Symbol(pb5, Decl(promiseTypeStrictNull.ts, 202, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Symbol(pb6, Decl(promiseTypeStrictNull.ts, 203, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Symbol(pb7, Decl(promiseTypeStrictNull.ts, 204, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Symbol(pb8, Decl(promiseTypeStrictNull.ts, 205, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Symbol(pb9, Decl(promiseTypeStrictNull.ts, 206, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc0 = p.then(() => Promise.reject("1"), undefined);
 >pc0 : Symbol(pc0, Decl(promiseTypeStrictNull.ts, 208, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pc1 = p.then(() => Promise.reject("1"), null);
 >pc1 : Symbol(pc1, Decl(promiseTypeStrictNull.ts, 209, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >pc2 : Symbol(pc2, Decl(promiseTypeStrictNull.ts, 210, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc3 = p.then(() => Promise.reject("1"), () => x);
 >pc3 : Symbol(pc3, Decl(promiseTypeStrictNull.ts, 211, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >pc4 : Symbol(pc4, Decl(promiseTypeStrictNull.ts, 212, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pc5 = p.then(() => Promise.reject("1"), () => null);
 >pc5 : Symbol(pc5, Decl(promiseTypeStrictNull.ts, 213, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc6 = p.then(() => Promise.reject("1"), () => {});
 >pc6 : Symbol(pc6, Decl(promiseTypeStrictNull.ts, 214, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >pc7 : Symbol(pc7, Decl(promiseTypeStrictNull.ts, 215, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >pc8 : Symbol(pc8, Decl(promiseTypeStrictNull.ts, 216, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Symbol(pc9, Decl(promiseTypeStrictNull.ts, 217, 5))
->p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 184ffd32592..c923ea234d8 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -22,13 +22,13 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -47,22 +47,22 @@ function f2(x: T1): T2 {
 
 var x3 = f1()
 >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3))
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->f1()    .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
+>f1()    .then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Error : Symbol(Error, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     throw e;
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols b/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols
index dc0be21d84f..36544cc1c40 100644
--- a/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols
@@ -1,21 +1,21 @@
 === tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts ===
 0xffffffff.toString();
->0xffffffff.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>0xffffffff.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
 0o01234.toString();
->0o01234.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>0o01234.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
 0b01101101.toString();
->0b01101101.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>0b01101101.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
 1234..toString();
->1234..toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>1234..toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
 1e0.toString();
->1e0.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>1e0.toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
index 6fbb89f00de..4fba2250833 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
@@ -5,7 +5,7 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     f() {
 >f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25))
@@ -31,13 +31,13 @@ var r = (new C<Date>()).f();
 >r : Symbol(r, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 3))
 >(new C<Date>()).f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25))
 >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25))
 
 interface I<T extends Date> {
 >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 28))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: T;
 >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29))
@@ -46,7 +46,7 @@ interface I<T extends Date> {
 var i: I<Date>;
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3))
 >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 28))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r2 = i.foo.getDate();
 >r2 : Symbol(r2, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 17, 3))
@@ -68,14 +68,14 @@ var a: {
 
     <T extends Date>(): T;
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 21, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 21, 5))
 }
 var r3 = a<Date>().getDate();
 >r3 : Symbol(r3, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 23, 3))
 >a<Date>().getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 var r3b = a()['getDate']();
@@ -89,7 +89,7 @@ var b = {
     foo: <T extends Date>(x: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10))
 
@@ -111,5 +111,5 @@ var r4 = b.foo(new Date());
 >b.foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3))
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints4.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints4.symbols
index aafc8da5d2c..ebd33d4dcc1 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints4.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints4.symbols
@@ -2,7 +2,7 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 0, 0))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 0, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     f() {
 >f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 0, 25))
@@ -25,13 +25,13 @@ var r = (new C<Date>()).f();
 >r : Symbol(r, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 8, 3))
 >(new C<Date>()).f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 0, 25))
 >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 0, 25))
 
 interface I<T extends Date> {
 >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 8, 28))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 10, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: T;
 >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 10, 29))
@@ -40,7 +40,7 @@ interface I<T extends Date> {
 var i: I<Date>;
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 13, 3))
 >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 8, 28))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r2 = i.foo.notHere();
 >r2 : Symbol(r2, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 14, 3))
@@ -59,7 +59,7 @@ var a: {
 
     <T extends Date>(): T;
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 18, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 18, 5))
 }
 var r3: string = a().notHere();
@@ -76,7 +76,7 @@ var b = {
     foo: <T extends Date>(x: T): T => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 23, 9))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 24, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 24, 26))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 24, 10))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 24, 10))
@@ -98,5 +98,5 @@ var b = {
 var r4 = b.foo(new Date());
 >r4 : Symbol(r4, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 31, 3))
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints4.ts, 23, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/reachabilityCheckWithEmptyDefault.symbols b/tests/baselines/reference/reachabilityCheckWithEmptyDefault.symbols
index d3123c0e8ba..1133cf38daa 100644
--- a/tests/baselines/reference/reachabilityCheckWithEmptyDefault.symbols
+++ b/tests/baselines/reference/reachabilityCheckWithEmptyDefault.symbols
@@ -1,6 +1,6 @@
 === tests/cases/compiler/reachabilityCheckWithEmptyDefault.ts ===
 declare function print(s: string): void;
->print : Symbol(print, Decl(reachabilityCheckWithEmptyDefault.ts, 0, 0))
+>print : Symbol(print, Decl(lib.d.ts, --, --), Decl(reachabilityCheckWithEmptyDefault.ts, 0, 0))
 >s : Symbol(s, Decl(reachabilityCheckWithEmptyDefault.ts, 0, 23))
 
 function foo(x: any) {
@@ -14,5 +14,5 @@ function foo(x: any) {
 		default:
 	}
 	print('1');
->print : Symbol(print, Decl(reachabilityCheckWithEmptyDefault.ts, 0, 0))
+>print : Symbol(print, Decl(lib.d.ts, --, --), Decl(reachabilityCheckWithEmptyDefault.ts, 0, 0))
 }
diff --git a/tests/baselines/reference/reachabilityCheckWithEmptyDefault.types b/tests/baselines/reference/reachabilityCheckWithEmptyDefault.types
index 72c23eae972..1125a2cd88a 100644
--- a/tests/baselines/reference/reachabilityCheckWithEmptyDefault.types
+++ b/tests/baselines/reference/reachabilityCheckWithEmptyDefault.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/reachabilityCheckWithEmptyDefault.ts ===
 declare function print(s: string): void;
->print : (s: string) => void
+>print : { (): void; (s: string): void; }
 >s : string
 
 function foo(x: any) {
@@ -17,6 +17,6 @@ function foo(x: any) {
 	}
 	print('1');
 >print('1') : void
->print : (s: string) => void
+>print : { (): void; (s: string): void; }
 >'1' : "1"
 }
diff --git a/tests/baselines/reference/reachabilityChecks7.symbols b/tests/baselines/reference/reachabilityChecks7.symbols
index c1b317c12f2..1a2e1d01f57 100644
--- a/tests/baselines/reference/reachabilityChecks7.symbols
+++ b/tests/baselines/reference/reachabilityChecks7.symbols
@@ -11,7 +11,7 @@ let x = async function() {
 // async function with which promised type is void - return can be omitted
 async function f2(): Promise<void> {
 >f2 : Symbol(f2, Decl(reachabilityChecks7.ts, 5, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     
 }
 
@@ -25,7 +25,7 @@ async function f3(x) {
 
 async function f4(): Promise<number> {
 >f4 : Symbol(f4, Decl(reachabilityChecks7.ts, 14, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
     
 }
 
diff --git a/tests/baselines/reference/restParametersOfNonArrayTypes.symbols b/tests/baselines/reference/restParametersOfNonArrayTypes.symbols
index c7405c7c6ff..ff0351a5866 100644
--- a/tests/baselines/reference/restParametersOfNonArrayTypes.symbols
+++ b/tests/baselines/reference/restParametersOfNonArrayTypes.symbols
@@ -13,7 +13,7 @@ var f = function foo(...x: number) { }
 var f2 = (...x: Date, ...y: boolean) => { }
 >f2 : Symbol(f2, Decl(restParametersOfNonArrayTypes.ts, 4, 3))
 >x : Symbol(x, Decl(restParametersOfNonArrayTypes.ts, 4, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(restParametersOfNonArrayTypes.ts, 4, 21))
 
 class C {
@@ -60,7 +60,7 @@ var b = {
 >foo : Symbol(foo, Decl(restParametersOfNonArrayTypes.ts, 22, 6))
 >x : Symbol(x, Decl(restParametersOfNonArrayTypes.ts, 22, 20))
 >y : Symbol(y, Decl(restParametersOfNonArrayTypes.ts, 22, 33))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     b: (...x: string) => { }
 >b : Symbol(b, Decl(restParametersOfNonArrayTypes.ts, 22, 50))
diff --git a/tests/baselines/reference/returnStatements.symbols b/tests/baselines/reference/returnStatements.symbols
index af8aa2af7df..65e90694184 100644
--- a/tests/baselines/reference/returnStatements.symbols
+++ b/tests/baselines/reference/returnStatements.symbols
@@ -18,8 +18,8 @@ function fn5(): boolean { return true; }
 
 function fn6(): Date { return new Date(12); }
 >fn6 : Symbol(fn6, Decl(returnStatements.ts, 5, 40))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn7(): any { return null; }
 >fn7 : Symbol(fn7, Decl(returnStatements.ts, 6, 45))
diff --git a/tests/baselines/reference/scopeResolutionIdentifiers.symbols b/tests/baselines/reference/scopeResolutionIdentifiers.symbols
index ecabe30534e..d0e2e41c82d 100644
--- a/tests/baselines/reference/scopeResolutionIdentifiers.symbols
+++ b/tests/baselines/reference/scopeResolutionIdentifiers.symbols
@@ -51,7 +51,7 @@ class C {
 
     s: Date;
 >s : Symbol(C.s, Decl(scopeResolutionIdentifiers.ts, 21, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     n = this.s;
 >n : Symbol(C.n, Decl(scopeResolutionIdentifiers.ts, 22, 12))
@@ -70,7 +70,7 @@ class C {
 
         var p: Date;
 >p : Symbol(p, Decl(scopeResolutionIdentifiers.ts, 25, 11), Decl(scopeResolutionIdentifiers.ts, 26, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/sourceMapValidationFor.errors.txt b/tests/baselines/reference/sourceMapValidationFor.errors.txt
index c64544c4b6c..ffc981648d6 100644
--- a/tests/baselines/reference/sourceMapValidationFor.errors.txt
+++ b/tests/baselines/reference/sourceMapValidationFor.errors.txt
@@ -1,20 +1,14 @@
-tests/cases/compiler/sourceMapValidationFor.ts(2,5): error TS2304: Cannot find name 'WScript'.
-tests/cases/compiler/sourceMapValidationFor.ts(6,5): error TS2304: Cannot find name 'WScript'.
 tests/cases/compiler/sourceMapValidationFor.ts(20,1): error TS7027: Unreachable code detected.
 tests/cases/compiler/sourceMapValidationFor.ts(32,21): error TS2695: Left side of comma operator is unused and has no side effects.
 
 
-==== tests/cases/compiler/sourceMapValidationFor.ts (4 errors) ====
+==== tests/cases/compiler/sourceMapValidationFor.ts (2 errors) ====
     for (var i = 0; i < 10; i++) {
         WScript.Echo("i: " + i);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'WScript'.
     }
     for (i = 0; i < 10; i++)
     {
         WScript.Echo("i: " + i);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'WScript'.
     }
     for (var j = 0; j < 10; ) {
         j++;
diff --git a/tests/baselines/reference/sourceMapValidationFor.symbols b/tests/baselines/reference/sourceMapValidationFor.symbols
index 966f905ae5d..c9031f54cec 100644
--- a/tests/baselines/reference/sourceMapValidationFor.symbols
+++ b/tests/baselines/reference/sourceMapValidationFor.symbols
@@ -5,6 +5,9 @@ for (var i = 0; i < 10; i++) {
 >i : Symbol(i, Decl(sourceMapValidationFor.ts, 0, 8))
 
     WScript.Echo("i: " + i);
+>WScript.Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
+>WScript : Symbol(WScript, Decl(lib.d.ts, --, --))
+>Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(sourceMapValidationFor.ts, 0, 8))
 }
 for (i = 0; i < 10; i++)
@@ -13,6 +16,9 @@ for (i = 0; i < 10; i++)
 >i : Symbol(i, Decl(sourceMapValidationFor.ts, 0, 8))
 {
     WScript.Echo("i: " + i);
+>WScript.Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
+>WScript : Symbol(WScript, Decl(lib.d.ts, --, --))
+>Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(sourceMapValidationFor.ts, 0, 8))
 }
 for (var j = 0; j < 10; ) {
diff --git a/tests/baselines/reference/sourceMapValidationFor.types b/tests/baselines/reference/sourceMapValidationFor.types
index 72384afb168..896991f850c 100644
--- a/tests/baselines/reference/sourceMapValidationFor.types
+++ b/tests/baselines/reference/sourceMapValidationFor.types
@@ -9,10 +9,10 @@ for (var i = 0; i < 10; i++) {
 >i : number
 
     WScript.Echo("i: " + i);
->WScript.Echo("i: " + i) : any
->WScript.Echo : any
->WScript : any
->Echo : any
+>WScript.Echo("i: " + i) : void
+>WScript.Echo : (s: any) => void
+>WScript : { Echo(s: any): void; StdErr: TextStreamWriter; StdOut: TextStreamWriter; Arguments: { length: number; Item(n: number): string; }; ScriptFullName: string; Quit(exitCode?: number): number; BuildVersion: number; FullName: string; Interactive: boolean; Name: string; Path: string; ScriptName: string; StdIn: TextStreamReader; Version: string; ConnectObject(objEventSource: any, strPrefix: string): void; CreateObject(strProgID: string, strPrefix?: string): any; DisconnectObject(obj: any): void; GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any; Sleep(intTime: number): void; }
+>Echo : (s: any) => void
 >"i: " + i : string
 >"i: " : "i: "
 >i : number
@@ -28,10 +28,10 @@ for (i = 0; i < 10; i++)
 >i : number
 {
     WScript.Echo("i: " + i);
->WScript.Echo("i: " + i) : any
->WScript.Echo : any
->WScript : any
->Echo : any
+>WScript.Echo("i: " + i) : void
+>WScript.Echo : (s: any) => void
+>WScript : { Echo(s: any): void; StdErr: TextStreamWriter; StdOut: TextStreamWriter; Arguments: { length: number; Item(n: number): string; }; ScriptFullName: string; Quit(exitCode?: number): number; BuildVersion: number; FullName: string; Interactive: boolean; Name: string; Path: string; ScriptName: string; StdIn: TextStreamReader; Version: string; ConnectObject(objEventSource: any, strPrefix: string): void; CreateObject(strProgID: string, strPrefix?: string): any; DisconnectObject(obj: any): void; GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any; Sleep(intTime: number): void; }
+>Echo : (s: any) => void
 >"i: " + i : string
 >"i: " : "i: "
 >i : number
diff --git a/tests/baselines/reference/sourceMapValidationForIn.errors.txt b/tests/baselines/reference/sourceMapValidationForIn.errors.txt
deleted file mode 100644
index 018d1b795dc..00000000000
--- a/tests/baselines/reference/sourceMapValidationForIn.errors.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-tests/cases/compiler/sourceMapValidationForIn.ts(2,5): error TS2304: Cannot find name 'WScript'.
-tests/cases/compiler/sourceMapValidationForIn.ts(5,5): error TS2304: Cannot find name 'WScript'.
-tests/cases/compiler/sourceMapValidationForIn.ts(9,5): error TS2304: Cannot find name 'WScript'.
-tests/cases/compiler/sourceMapValidationForIn.ts(13,5): error TS2304: Cannot find name 'WScript'.
-
-
-==== tests/cases/compiler/sourceMapValidationForIn.ts (4 errors) ====
-    for (var x in String) {
-        WScript.Echo(x);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'WScript'.
-    }
-    for (x in String) {
-        WScript.Echo(x);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'WScript'.
-    }
-    for (var x2 in String)
-    {
-        WScript.Echo(x2);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'WScript'.
-    }
-    for (x in String)
-    {
-        WScript.Echo(x);
-        ~~~~~~~
-!!! error TS2304: Cannot find name 'WScript'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/sourceMapValidationForIn.symbols b/tests/baselines/reference/sourceMapValidationForIn.symbols
index ce9444d28ab..89edde365df 100644
--- a/tests/baselines/reference/sourceMapValidationForIn.symbols
+++ b/tests/baselines/reference/sourceMapValidationForIn.symbols
@@ -4,6 +4,9 @@ for (var x in String) {
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     WScript.Echo(x);
+>WScript.Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
+>WScript : Symbol(WScript, Decl(lib.d.ts, --, --))
+>Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(sourceMapValidationForIn.ts, 0, 8))
 }
 for (x in String) {
@@ -11,6 +14,9 @@ for (x in String) {
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     WScript.Echo(x);
+>WScript.Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
+>WScript : Symbol(WScript, Decl(lib.d.ts, --, --))
+>Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(sourceMapValidationForIn.ts, 0, 8))
 }
 for (var x2 in String)
@@ -18,6 +24,9 @@ for (var x2 in String)
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 {
     WScript.Echo(x2);
+>WScript.Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
+>WScript : Symbol(WScript, Decl(lib.d.ts, --, --))
+>Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
 >x2 : Symbol(x2, Decl(sourceMapValidationForIn.ts, 6, 8))
 }
 for (x in String)
@@ -25,5 +34,8 @@ for (x in String)
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 {
     WScript.Echo(x);
+>WScript.Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
+>WScript : Symbol(WScript, Decl(lib.d.ts, --, --))
+>Echo : Symbol(Echo, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(sourceMapValidationForIn.ts, 0, 8))
 }
diff --git a/tests/baselines/reference/sourceMapValidationForIn.types b/tests/baselines/reference/sourceMapValidationForIn.types
index da4bb29f9b8..7fc1fb7d413 100644
--- a/tests/baselines/reference/sourceMapValidationForIn.types
+++ b/tests/baselines/reference/sourceMapValidationForIn.types
@@ -4,10 +4,10 @@ for (var x in String) {
 >String : StringConstructor
 
     WScript.Echo(x);
->WScript.Echo(x) : any
->WScript.Echo : any
->WScript : any
->Echo : any
+>WScript.Echo(x) : void
+>WScript.Echo : (s: any) => void
+>WScript : { Echo(s: any): void; StdErr: TextStreamWriter; StdOut: TextStreamWriter; Arguments: { length: number; Item(n: number): string; }; ScriptFullName: string; Quit(exitCode?: number): number; BuildVersion: number; FullName: string; Interactive: boolean; Name: string; Path: string; ScriptName: string; StdIn: TextStreamReader; Version: string; ConnectObject(objEventSource: any, strPrefix: string): void; CreateObject(strProgID: string, strPrefix?: string): any; DisconnectObject(obj: any): void; GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any; Sleep(intTime: number): void; }
+>Echo : (s: any) => void
 >x : string
 }
 for (x in String) {
@@ -15,10 +15,10 @@ for (x in String) {
 >String : StringConstructor
 
     WScript.Echo(x);
->WScript.Echo(x) : any
->WScript.Echo : any
->WScript : any
->Echo : any
+>WScript.Echo(x) : void
+>WScript.Echo : (s: any) => void
+>WScript : { Echo(s: any): void; StdErr: TextStreamWriter; StdOut: TextStreamWriter; Arguments: { length: number; Item(n: number): string; }; ScriptFullName: string; Quit(exitCode?: number): number; BuildVersion: number; FullName: string; Interactive: boolean; Name: string; Path: string; ScriptName: string; StdIn: TextStreamReader; Version: string; ConnectObject(objEventSource: any, strPrefix: string): void; CreateObject(strProgID: string, strPrefix?: string): any; DisconnectObject(obj: any): void; GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any; Sleep(intTime: number): void; }
+>Echo : (s: any) => void
 >x : string
 }
 for (var x2 in String)
@@ -26,10 +26,10 @@ for (var x2 in String)
 >String : StringConstructor
 {
     WScript.Echo(x2);
->WScript.Echo(x2) : any
->WScript.Echo : any
->WScript : any
->Echo : any
+>WScript.Echo(x2) : void
+>WScript.Echo : (s: any) => void
+>WScript : { Echo(s: any): void; StdErr: TextStreamWriter; StdOut: TextStreamWriter; Arguments: { length: number; Item(n: number): string; }; ScriptFullName: string; Quit(exitCode?: number): number; BuildVersion: number; FullName: string; Interactive: boolean; Name: string; Path: string; ScriptName: string; StdIn: TextStreamReader; Version: string; ConnectObject(objEventSource: any, strPrefix: string): void; CreateObject(strProgID: string, strPrefix?: string): any; DisconnectObject(obj: any): void; GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any; Sleep(intTime: number): void; }
+>Echo : (s: any) => void
 >x2 : string
 }
 for (x in String)
@@ -37,9 +37,9 @@ for (x in String)
 >String : StringConstructor
 {
     WScript.Echo(x);
->WScript.Echo(x) : any
->WScript.Echo : any
->WScript : any
->Echo : any
+>WScript.Echo(x) : void
+>WScript.Echo : (s: any) => void
+>WScript : { Echo(s: any): void; StdErr: TextStreamWriter; StdOut: TextStreamWriter; Arguments: { length: number; Item(n: number): string; }; ScriptFullName: string; Quit(exitCode?: number): number; BuildVersion: number; FullName: string; Interactive: boolean; Name: string; Path: string; ScriptName: string; StdIn: TextStreamReader; Version: string; ConnectObject(objEventSource: any, strPrefix: string): void; CreateObject(strProgID: string, strPrefix?: string): any; DisconnectObject(obj: any): void; GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any; Sleep(intTime: number): void; }
+>Echo : (s: any) => void
 >x : string
 }
diff --git a/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.symbols b/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.symbols
index f262fb43781..4d16c332d82 100644
--- a/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.symbols
+++ b/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.symbols
@@ -6,10 +6,10 @@ module M {
 >X : Symbol(X, Decl(a.ts, 1, 14))
 }
 interface Navigator {
->Navigator : Symbol(Navigator, Decl(a.ts, 2, 1))
+>Navigator : Symbol(Navigator, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(a.ts, 2, 1))
 
     getGamepads(func?: any): any;
->getGamepads : Symbol(Navigator.getGamepads, Decl(a.ts, 3, 21))
+>getGamepads : Symbol(Navigator.getGamepads, Decl(lib.d.ts, --, --), Decl(a.ts, 3, 21))
 >func : Symbol(func, Decl(a.ts, 4, 16))
 
     webkitGetGamepads(func?: any): any
diff --git a/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.types b/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.types
index d3a26c4114e..6fbbe7d6fc5 100644
--- a/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.types
+++ b/tests/baselines/reference/sourceMapWithMultipleFilesWithFileEndingWithInterface.types
@@ -10,7 +10,7 @@ interface Navigator {
 >Navigator : Navigator
 
     getGamepads(func?: any): any;
->getGamepads : (func?: any) => any
+>getGamepads : { (): Gamepad[]; (func?: any): any; }
 >func : any
 
     webkitGetGamepads(func?: any): any
diff --git a/tests/baselines/reference/staticMembersUsingClassTypeParameter.symbols b/tests/baselines/reference/staticMembersUsingClassTypeParameter.symbols
index df80c94fb9f..862f651c971 100644
--- a/tests/baselines/reference/staticMembersUsingClassTypeParameter.symbols
+++ b/tests/baselines/reference/staticMembersUsingClassTypeParameter.symbols
@@ -28,7 +28,7 @@ class C2<T, U> {
 class C3<T extends Date> {
 >C3 : Symbol(C3, Decl(staticMembersUsingClassTypeParameter.ts, 9, 1))
 >T : Symbol(T, Decl(staticMembersUsingClassTypeParameter.ts, 11, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     static x: T;
 >x : Symbol(C3.x, Decl(staticMembersUsingClassTypeParameter.ts, 11, 26))
diff --git a/tests/baselines/reference/stringIncludes.symbols b/tests/baselines/reference/stringIncludes.symbols
index ba3c5ade73e..d5830f6aab1 100644
--- a/tests/baselines/reference/stringIncludes.symbols
+++ b/tests/baselines/reference/stringIncludes.symbols
@@ -4,11 +4,11 @@ var includes: boolean;
 
 includes = "abcde".includes("cd");
 >includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --))
->includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --))
+>"abcde".includes : Symbol(String.includes, Decl(lib.es6.d.ts, --, --))
+>includes : Symbol(String.includes, Decl(lib.es6.d.ts, --, --))
 
 includes = "abcde".includes("cd", 2);
 >includes : Symbol(includes, Decl(stringIncludes.ts, 0, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --))
->includes : Symbol(String.includes, Decl(lib.es2015.core.d.ts, --, --))
+>"abcde".includes : Symbol(String.includes, Decl(lib.es6.d.ts, --, --))
+>includes : Symbol(String.includes, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.symbols b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.symbols
index e97b2a59118..b656c54d944 100644
--- a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.symbols
+++ b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.symbols
@@ -84,7 +84,7 @@ function f7(x: 'a');
 function f7(x: Date);
 >f7 : Symbol(f7, Decl(stringLiteralTypeIsSubtypeOfString.ts, 27, 23), Decl(stringLiteralTypeIsSubtypeOfString.ts, 29, 20), Decl(stringLiteralTypeIsSubtypeOfString.ts, 30, 21))
 >x : Symbol(x, Decl(stringLiteralTypeIsSubtypeOfString.ts, 30, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function f7(x: any) { }
 >f7 : Symbol(f7, Decl(stringLiteralTypeIsSubtypeOfString.ts, 27, 23), Decl(stringLiteralTypeIsSubtypeOfString.ts, 29, 20), Decl(stringLiteralTypeIsSubtypeOfString.ts, 30, 21))
diff --git a/tests/baselines/reference/subtypesOfAny.symbols b/tests/baselines/reference/subtypesOfAny.symbols
index 5e5353e8c9d..8429aea06e4 100644
--- a/tests/baselines/reference/subtypesOfAny.symbols
+++ b/tests/baselines/reference/subtypesOfAny.symbols
@@ -53,7 +53,7 @@ interface I5 {
 
     foo: Date;
 >foo : Symbol(I5.foo, Decl(subtypesOfAny.ts, 27, 21))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
diff --git a/tests/baselines/reference/subtypesOfTypeParameter.symbols b/tests/baselines/reference/subtypesOfTypeParameter.symbols
index b3988b0aa41..c01c5ae7b82 100644
--- a/tests/baselines/reference/subtypesOfTypeParameter.symbols
+++ b/tests/baselines/reference/subtypesOfTypeParameter.symbols
@@ -138,13 +138,13 @@ function f2<T, U>(x: T, y: U) {
 
     var r4 = true ? new Date() : x;
 >r4 : Symbol(r4, Decl(subtypesOfTypeParameter.ts, 46, 7), Decl(subtypesOfTypeParameter.ts, 47, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(subtypesOfTypeParameter.ts, 29, 18))
 
     var r4 = true ? x : new Date();
 >r4 : Symbol(r4, Decl(subtypesOfTypeParameter.ts, 46, 7), Decl(subtypesOfTypeParameter.ts, 47, 7))
 >x : Symbol(x, Decl(subtypesOfTypeParameter.ts, 29, 18))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     var r5 = true ? /1/ : x;
 >r5 : Symbol(r5, Decl(subtypesOfTypeParameter.ts, 49, 7), Decl(subtypesOfTypeParameter.ts, 50, 7))
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints.symbols b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints.symbols
index b43bafcdf6d..3fc027f8cce 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints.symbols
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints.symbols
@@ -267,13 +267,13 @@ class D14<T extends U, U extends V, V extends Date> extends C3<Date> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 82, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 82, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 82, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: string]: Date;
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints.ts, 83, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: T; // ok
 >foo : Symbol(D14.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 83, 22))
@@ -287,7 +287,7 @@ class D15<T extends U, U extends V, V extends Date> extends C3<T> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 87, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 87, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 87, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints.ts, 87, 10))
 
@@ -307,7 +307,7 @@ class D16<T extends U, U extends V, V extends Date> extends C3<U> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 92, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 92, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 92, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 92, 22))
 
@@ -327,7 +327,7 @@ class D17<T extends U, U extends V, V extends Date> extends C3<V> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 97, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 97, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 97, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 97, 35))
 
@@ -349,13 +349,13 @@ class D18<T extends U, U extends V, V extends Date> extends C3<Date> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 104, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 104, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 104, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: string]: Date;
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints.ts, 105, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: T; // ok
 >foo : Symbol(D18.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 105, 22))
@@ -369,7 +369,7 @@ class D19<T extends U, U extends V, V extends Date> extends C3<T> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 109, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 109, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 109, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints.ts, 109, 10))
 
@@ -389,7 +389,7 @@ class D20<T extends U, U extends V, V extends Date> extends C3<U> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 114, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 114, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 114, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 114, 22))
 
@@ -409,7 +409,7 @@ class D21<T extends U, U extends V, V extends Date> extends C3<V> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 119, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 119, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 119, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 119, 35))
 
@@ -431,13 +431,13 @@ class D22<T extends U, U extends V, V extends Date> extends C3<Date> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 126, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 126, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 126, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: string]: Date;
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints.ts, 127, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: T; // ok
 >foo : Symbol(D22.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 127, 22))
@@ -451,7 +451,7 @@ class D23<T extends U, U extends V, V extends Date> extends C3<T> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 131, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 131, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 131, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints.ts, 131, 10))
 
@@ -471,7 +471,7 @@ class D24<T extends U, U extends V, V extends Date> extends C3<U> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 136, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 136, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 136, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 136, 22))
 
@@ -491,7 +491,7 @@ class D25<T extends U, U extends V, V extends Date> extends C3<V> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 141, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 141, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 141, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 141, 35))
 
@@ -513,17 +513,17 @@ class D26<T extends U, U extends V, V extends Date> extends C3<Date> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 148, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 148, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 148, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: string]: Date;
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints.ts, 149, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: Date; // ok
 >foo : Symbol(D26.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 149, 22))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class D27<T extends U, U extends V, V extends Date> extends C3<T> {
@@ -533,7 +533,7 @@ class D27<T extends U, U extends V, V extends Date> extends C3<T> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 153, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 153, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 153, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints.ts, 153, 10))
 
@@ -543,7 +543,7 @@ class D27<T extends U, U extends V, V extends Date> extends C3<T> {
 
     foo: Date; // error
 >foo : Symbol(D27.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 154, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class D28<T extends U, U extends V, V extends Date> extends C3<U> {
@@ -553,7 +553,7 @@ class D28<T extends U, U extends V, V extends Date> extends C3<U> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 158, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 158, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 158, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 158, 22))
 
@@ -563,7 +563,7 @@ class D28<T extends U, U extends V, V extends Date> extends C3<U> {
 
     foo: Date; // error
 >foo : Symbol(D28.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 159, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class D29<T extends U, U extends V, V extends Date> extends C3<V> {
@@ -573,7 +573,7 @@ class D29<T extends U, U extends V, V extends Date> extends C3<V> {
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints.ts, 163, 22))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 163, 35))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 163, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C3 : Symbol(C3, Decl(subtypesOfTypeParameterWithConstraints.ts, 0, 0))
 >V : Symbol(V, Decl(subtypesOfTypeParameterWithConstraints.ts, 163, 35))
 
@@ -583,5 +583,5 @@ class D29<T extends U, U extends V, V extends Date> extends C3<V> {
 
     foo: Date; // error
 >foo : Symbol(D29.foo, Decl(subtypesOfTypeParameterWithConstraints.ts, 164, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.symbols b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.symbols
index b33b9d212f2..e28bd3c05ba 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.symbols
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.symbols
@@ -76,7 +76,7 @@ function f3<T extends U, U extends Date>(x: T, y: U) {
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 12))
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 24))
 >U : Symbol(U, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 24))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 41))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 12))
 >y : Symbol(y, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 46))
@@ -96,22 +96,22 @@ function f3<T extends U, U extends Date>(x: T, y: U) {
     var r2 = true ? x : new Date(); 
 >r2 : Symbol(r2, Decl(subtypesOfTypeParameterWithConstraints2.ts, 27, 7), Decl(subtypesOfTypeParameterWithConstraints2.ts, 28, 7))
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 41))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     var r2 = true ? new Date() : x;
 >r2 : Symbol(r2, Decl(subtypesOfTypeParameterWithConstraints2.ts, 27, 7), Decl(subtypesOfTypeParameterWithConstraints2.ts, 28, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 41))
 
     // ok
     var r3 = true ? y : new Date(); 
 >r3 : Symbol(r3, Decl(subtypesOfTypeParameterWithConstraints2.ts, 31, 7), Decl(subtypesOfTypeParameterWithConstraints2.ts, 32, 7))
 >y : Symbol(y, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 46))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     var r3 = true ? new Date() : y;
 >r3 : Symbol(r3, Decl(subtypesOfTypeParameterWithConstraints2.ts, 31, 7), Decl(subtypesOfTypeParameterWithConstraints2.ts, 32, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(subtypesOfTypeParameterWithConstraints2.ts, 22, 46))
 }
 
@@ -235,19 +235,19 @@ function f7<T extends Boolean>(x: T) {
 function f8<T extends Date>(x: T) {
 >f8 : Symbol(f8, Decl(subtypesOfTypeParameterWithConstraints2.ts, 71, 1))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints2.ts, 73, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints2.ts, 73, 28))
 >T : Symbol(T, Decl(subtypesOfTypeParameterWithConstraints2.ts, 73, 12))
 
     var r4 = true ? new Date() : x; // ok
 >r4 : Symbol(r4, Decl(subtypesOfTypeParameterWithConstraints2.ts, 74, 7), Decl(subtypesOfTypeParameterWithConstraints2.ts, 75, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints2.ts, 73, 28))
 
     var r4 = true ? x : new Date(); // ok
 >r4 : Symbol(r4, Decl(subtypesOfTypeParameterWithConstraints2.ts, 74, 7), Decl(subtypesOfTypeParameterWithConstraints2.ts, 75, 7))
 >x : Symbol(x, Decl(subtypesOfTypeParameterWithConstraints2.ts, 73, 28))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 function f9<T extends RegExp>(x: T) {
diff --git a/tests/baselines/reference/subtypesOfUnion.symbols b/tests/baselines/reference/subtypesOfUnion.symbols
index 17a9cdf96f2..999760c7e0c 100644
--- a/tests/baselines/reference/subtypesOfUnion.symbols
+++ b/tests/baselines/reference/subtypesOfUnion.symbols
@@ -59,7 +59,7 @@ interface I1<T> {
 
     foo6: Date; // error
 >foo6 : Symbol(I1.foo6, Decl(subtypesOfUnion.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo7: RegExp; // error
 >foo7 : Symbol(I1.foo7, Decl(subtypesOfUnion.ts, 17, 15))
@@ -137,7 +137,7 @@ interface I2<T> {
 
     foo6: Date; // error
 >foo6 : Symbol(I2.foo6, Decl(subtypesOfUnion.ts, 37, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo7: RegExp; // error
 >foo7 : Symbol(I2.foo7, Decl(subtypesOfUnion.ts, 38, 15))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.symbols b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
index 95158bb25d9..7963a0fc414 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
@@ -297,8 +297,8 @@ declare function foo18(a: {
 
         (a: Date): Date;
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 74, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }): typeof a;
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.symbols b/tests/baselines/reference/subtypingWithConstructSignatures2.symbols
index cbb72b9f396..b66b6b0db20 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures2.symbols
+++ b/tests/baselines/reference/subtypingWithConstructSignatures2.symbols
@@ -297,8 +297,8 @@ declare function foo18(a: {
 
         new (a: Date): Date;
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 74, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }): typeof a;
diff --git a/tests/baselines/reference/superSymbolIndexedAccess1.symbols b/tests/baselines/reference/superSymbolIndexedAccess1.symbols
index 9141771f0c9..3eae80f32c9 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess1.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess1.ts ===
 var symbol = Symbol.for('myThing');
 >symbol : Symbol(symbol, Decl(superSymbolIndexedAccess1.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess1.ts, 0, 35))
diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.symbols b/tests/baselines/reference/superSymbolIndexedAccess2.symbols
index 1e10d3a9f94..3c8a29bef2c 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess2.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess2.symbols
@@ -3,9 +3,9 @@ class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]() {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
         return 0;
     }
@@ -16,14 +16,14 @@ class Bar extends Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]() {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
         return super[Symbol.isConcatSpreadable]();
 >super : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/superSymbolIndexedAccess3.symbols b/tests/baselines/reference/superSymbolIndexedAccess3.symbols
index 6fde2737c91..81e9c9174ec 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess3.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess3.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess3.ts ===
 var symbol = Symbol.for('myThing');
 >symbol : Symbol(symbol, Decl(superSymbolIndexedAccess3.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess3.ts, 0, 35))
diff --git a/tests/baselines/reference/superSymbolIndexedAccess4.symbols b/tests/baselines/reference/superSymbolIndexedAccess4.symbols
index 8254361ecef..4bf8ea796c1 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess4.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess4.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess4.ts ===
 var symbol = Symbol.for('myThing');
 >symbol : Symbol(symbol, Decl(superSymbolIndexedAccess4.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 class Bar {
 >Bar : Symbol(Bar, Decl(superSymbolIndexedAccess4.ts, 0, 35))
diff --git a/tests/baselines/reference/switchStatements.symbols b/tests/baselines/reference/switchStatements.symbols
index af30b71af66..9d4a691d2ce 100644
--- a/tests/baselines/reference/switchStatements.symbols
+++ b/tests/baselines/reference/switchStatements.symbols
@@ -24,7 +24,7 @@ switch (x) {
 >undefined : Symbol(undefined)
 
     case new Date(12):
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     case new Object():
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
@@ -90,7 +90,7 @@ switch (undefined) { }
 >undefined : Symbol(undefined)
 
 switch (new Date(12)) { }
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 switch (new Object()) { }
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols
index 86f57e7de92..55fb0b38ba4 100644
--- a/tests/baselines/reference/symbolDeclarationEmit1.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0))
 
     [Symbol.toPrimitive]: number;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols
index bcc562e478e..68869dbc2b3 100644
--- a/tests/baselines/reference/symbolDeclarationEmit10.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols
@@ -3,13 +3,13 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3))
 
     get [Symbol.isConcatSpreadable]() { return '' },
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     set [Symbol.isConcatSpreadable](x) { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols
index 8b270daad5e..5157fb3bdfd 100644
--- a/tests/baselines/reference/symbolDeclarationEmit11.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols
@@ -3,23 +3,23 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0))
 
     static [Symbol.iterator] = 0;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     static [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     static get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     static set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit12.symbols b/tests/baselines/reference/symbolDeclarationEmit12.symbols
index 64d747cfbad..7ac8f81bf34 100644
--- a/tests/baselines/reference/symbolDeclarationEmit12.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit12.symbols
@@ -9,37 +9,37 @@ module M {
 >C : Symbol(C, Decl(symbolDeclarationEmit12.ts, 1, 19))
 
         [Symbol.iterator]: I;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >I : Symbol(I, Decl(symbolDeclarationEmit12.ts, 0, 10))
 
         [Symbol.toPrimitive](x: I) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit12.ts, 4, 29))
 >I : Symbol(I, Decl(symbolDeclarationEmit12.ts, 0, 10))
 
         [Symbol.isConcatSpreadable](): I {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 >I : Symbol(I, Decl(symbolDeclarationEmit12.ts, 0, 10))
 
             return undefined
 >undefined : Symbol(undefined)
         }
         get [Symbol.toPrimitive]() { return undefined; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >undefined : Symbol(undefined)
 
         set [Symbol.toPrimitive](x: I) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit12.ts, 9, 33))
 >I : Symbol(I, Decl(symbolDeclarationEmit12.ts, 0, 10))
     }
diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols
index b0884c44cb8..93420981a10 100644
--- a/tests/baselines/reference/symbolDeclarationEmit13.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols
@@ -3,13 +3,13 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     set [Symbol.toStringTag](x) { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols
index e20e3348309..2d5b394fcff 100644
--- a/tests/baselines/reference/symbolDeclarationEmit14.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols
@@ -3,12 +3,12 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     get [Symbol.toStringTag]() { return ""; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols
index 348760f0d7d..050fb90671e 100644
--- a/tests/baselines/reference/symbolDeclarationEmit2.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0))
 
     [Symbol.toPrimitive] = "";
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols
index 5bb8d67984e..f5f80347181 100644
--- a/tests/baselines/reference/symbolDeclarationEmit3.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols
@@ -3,20 +3,20 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0))
 
     [Symbol.toPrimitive](x: number);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25))
 
     [Symbol.toPrimitive](x: string);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25))
 
     [Symbol.toPrimitive](x: any) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols
index 89a4714f941..677aef893b2 100644
--- a/tests/baselines/reference/symbolDeclarationEmit4.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols
@@ -3,13 +3,13 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols
index bd1049b4e00..f37e669a4d1 100644
--- a/tests/baselines/reference/symbolDeclarationEmit5.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0))
 
     [Symbol.isConcatSpreadable](): string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols
index 19b86ff2b66..b7a54e7db92 100644
--- a/tests/baselines/reference/symbolDeclarationEmit6.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols
index 2cf42a5c5cc..8a03aeeb280 100644
--- a/tests/baselines/reference/symbolDeclarationEmit7.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols
@@ -3,7 +3,7 @@ var obj: {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols
index bb6c4728a08..c69f666c470 100644
--- a/tests/baselines/reference/symbolDeclarationEmit8.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: 0
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols
index 60fdbf63c95..37ba6536f9c 100644
--- a/tests/baselines/reference/symbolDeclarationEmit9.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty10.symbols b/tests/baselines/reference/symbolProperty10.symbols
index 7f873742221..59828041554 100644
--- a/tests/baselines/reference/symbolProperty10.symbols
+++ b/tests/baselines/reference/symbolProperty10.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty10.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty10.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty10.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty10.ts, 2, 1))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty10.ts, 4, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols
index bd1b433ed70..042e1f0eced 100644
--- a/tests/baselines/reference/symbolProperty11.symbols
+++ b/tests/baselines/reference/symbolProperty11.symbols
@@ -6,9 +6,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty12.symbols b/tests/baselines/reference/symbolProperty12.symbols
index a35f66f3cd1..47d3ecac2e7 100644
--- a/tests/baselines/reference/symbolProperty12.symbols
+++ b/tests/baselines/reference/symbolProperty12.symbols
@@ -3,18 +3,18 @@ class C {
 >C : Symbol(C, Decl(symbolProperty12.ts, 0, 0))
 
     private [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty12.ts, 1, 32))
 }
 interface I {
 >I : Symbol(I, Decl(symbolProperty12.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty12.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols
index e85e75f43d9..9cb29dcfa14 100644
--- a/tests/baselines/reference/symbolProperty13.symbols
+++ b/tests/baselines/reference/symbolProperty13.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols
index b13fbbc1f41..0de3cd69011 100644
--- a/tests/baselines/reference/symbolProperty14.symbols
+++ b/tests/baselines/reference/symbolProperty14.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols
index c9bea5e5db2..2f0641fcbd3 100644
--- a/tests/baselines/reference/symbolProperty15.symbols
+++ b/tests/baselines/reference/symbolProperty15.symbols
@@ -6,9 +6,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols
index 8e13d7babdf..8d31ef4219c 100644
--- a/tests/baselines/reference/symbolProperty16.symbols
+++ b/tests/baselines/reference/symbolProperty16.symbols
@@ -3,18 +3,18 @@ class C {
 >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0))
 
     private [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32))
 }
 interface I {
 >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty17.symbols b/tests/baselines/reference/symbolProperty17.symbols
index 688a391043b..baa5b5d5f08 100644
--- a/tests/baselines/reference/symbolProperty17.symbols
+++ b/tests/baselines/reference/symbolProperty17.symbols
@@ -3,9 +3,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty17.ts, 0, 0))
 
     [Symbol.iterator]: number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     [s: symbol]: string;
 >s : Symbol(s, Decl(symbolProperty17.ts, 2, 5))
@@ -20,7 +20,7 @@ var i: I;
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty17.ts, 7, 3))
 >i : Symbol(i, Decl(symbolProperty17.ts, 6, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols
index 54769192d90..590f55262ba 100644
--- a/tests/baselines/reference/symbolProperty18.symbols
+++ b/tests/baselines/reference/symbolProperty18.symbols
@@ -3,39 +3,39 @@ var i = {
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
 
     [Symbol.iterator]: 0,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.toStringTag]() { return "" },
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
     set [Symbol.toPrimitive](p: boolean) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29))
 }
 
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3))
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 var str = i[Symbol.toStringTag]();
 >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3))
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
 i[Symbol.toPrimitive] = false;
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols
index 5e8800e07cf..e903d75121c 100644
--- a/tests/baselines/reference/symbolProperty19.symbols
+++ b/tests/baselines/reference/symbolProperty19.symbols
@@ -3,15 +3,15 @@ var i = {
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
 
     [Symbol.iterator]: { p: null },
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24))
 
     [Symbol.toStringTag]() { return { p: undefined }; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37))
 >undefined : Symbol(undefined)
 }
@@ -19,14 +19,14 @@ var i = {
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3))
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 var str = i[Symbol.toStringTag]();
 >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3))
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols
index 90cb47c0011..5715e4a7485 100644
--- a/tests/baselines/reference/symbolProperty2.symbols
+++ b/tests/baselines/reference/symbolProperty2.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty2.ts ===
 var s = Symbol();
 >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols
index 60fc435898e..e2b227bea71 100644
--- a/tests/baselines/reference/symbolProperty20.symbols
+++ b/tests/baselines/reference/symbolProperty20.symbols
@@ -3,15 +3,15 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
 
     [Symbol.iterator]: (s: string) => string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24))
 
     [Symbol.toStringTag](s: number): number;
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25))
 }
 
@@ -20,16 +20,16 @@ var i: I = {
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
 
     [Symbol.iterator]: s => s,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 
     [Symbol.toStringTag](n) { return n; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 }
diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols
index 20310be60f3..d2deabcf611 100644
--- a/tests/baselines/reference/symbolProperty21.symbols
+++ b/tests/baselines/reference/symbolProperty21.symbols
@@ -5,15 +5,15 @@ interface I<T, U> {
 >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14))
 
     [Symbol.unscopables]: T;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(symbolProperty21.ts, 0, 12))
 
     [Symbol.isConcatSpreadable]: U;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14))
 }
 
@@ -34,18 +34,18 @@ foo({
 >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1))
 
     [Symbol.isConcatSpreadable]: "",
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.toPrimitive]: 0,
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.unscopables]: true
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 
 });
diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols
index e4e68d81970..331c9a33fa4 100644
--- a/tests/baselines/reference/symbolProperty22.symbols
+++ b/tests/baselines/reference/symbolProperty22.symbols
@@ -5,9 +5,9 @@ interface I<T, U> {
 >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14))
 
     [Symbol.unscopables](x: T): U;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25))
 >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12))
 >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14))
@@ -27,11 +27,11 @@ declare function foo<T, U>(p1: T, p2: I<T, U>): U;
 
 foo("", { [Symbol.unscopables]: s => s.length });
 >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1))
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
->s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>s.length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols
index 714b76fa85b..edfc83ac58e 100644
--- a/tests/baselines/reference/symbolProperty23.symbols
+++ b/tests/baselines/reference/symbolProperty23.symbols
@@ -3,9 +3,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0))
 
     [Symbol.toPrimitive]: () => boolean;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
 
 class C implements I {
@@ -13,9 +13,9 @@ class C implements I {
 >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0))
 
     [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
         return true;
     }
diff --git a/tests/baselines/reference/symbolProperty24.symbols b/tests/baselines/reference/symbolProperty24.symbols
index 197263e16b5..e5072faabbb 100644
--- a/tests/baselines/reference/symbolProperty24.symbols
+++ b/tests/baselines/reference/symbolProperty24.symbols
@@ -3,9 +3,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty24.ts, 0, 0))
 
     [Symbol.toPrimitive]: () => boolean;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
 
 class C implements I {
@@ -13,9 +13,9 @@ class C implements I {
 >I : Symbol(I, Decl(symbolProperty24.ts, 0, 0))
 
     [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty25.symbols b/tests/baselines/reference/symbolProperty25.symbols
index 06a5c01653c..ea7eb9ab719 100644
--- a/tests/baselines/reference/symbolProperty25.symbols
+++ b/tests/baselines/reference/symbolProperty25.symbols
@@ -3,9 +3,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty25.ts, 0, 0))
 
     [Symbol.toPrimitive]: () => boolean;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
 
 class C implements I {
@@ -13,9 +13,9 @@ class C implements I {
 >I : Symbol(I, Decl(symbolProperty25.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols
index 785a2e395cb..1a2983a78af 100644
--- a/tests/baselines/reference/symbolProperty26.symbols
+++ b/tests/baselines/reference/symbolProperty26.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
@@ -16,9 +16,9 @@ class C2 extends C1 {
 >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols
index 1b050b617c2..974b9484e74 100644
--- a/tests/baselines/reference/symbolProperty27.symbols
+++ b/tests/baselines/reference/symbolProperty27.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return {};
     }
@@ -16,9 +16,9 @@ class C2 extends C1 {
 >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols
index c72de5fefb5..0d5cbab048c 100644
--- a/tests/baselines/reference/symbolProperty28.symbols
+++ b/tests/baselines/reference/symbolProperty28.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
@@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x;
 >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3))
 >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 
diff --git a/tests/baselines/reference/symbolProperty29.symbols b/tests/baselines/reference/symbolProperty29.symbols
index 26ecd9a0f70..e18805b8636 100644
--- a/tests/baselines/reference/symbolProperty29.symbols
+++ b/tests/baselines/reference/symbolProperty29.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty29.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty29.ts, 2, 16))
diff --git a/tests/baselines/reference/symbolProperty3.symbols b/tests/baselines/reference/symbolProperty3.symbols
index ef35240eba1..8ae4cda24eb 100644
--- a/tests/baselines/reference/symbolProperty3.symbols
+++ b/tests/baselines/reference/symbolProperty3.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty3.ts ===
 var s = Symbol;
 >s : Symbol(s, Decl(symbolProperty3.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty3.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolProperty30.symbols b/tests/baselines/reference/symbolProperty30.symbols
index c4e758c58d8..7cc4076e1c5 100644
--- a/tests/baselines/reference/symbolProperty30.symbols
+++ b/tests/baselines/reference/symbolProperty30.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty30.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty30.ts, 2, 16))
diff --git a/tests/baselines/reference/symbolProperty31.symbols b/tests/baselines/reference/symbolProperty31.symbols
index 65fe5a0dd94..b75a38690b3 100644
--- a/tests/baselines/reference/symbolProperty31.symbols
+++ b/tests/baselines/reference/symbolProperty31.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty31.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty31.ts, 2, 16))
diff --git a/tests/baselines/reference/symbolProperty32.symbols b/tests/baselines/reference/symbolProperty32.symbols
index 6f069ac9b4e..c7c24c5de67 100644
--- a/tests/baselines/reference/symbolProperty32.symbols
+++ b/tests/baselines/reference/symbolProperty32.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty32.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty32.ts, 2, 16))
diff --git a/tests/baselines/reference/symbolProperty33.symbols b/tests/baselines/reference/symbolProperty33.symbols
index 1bcf313626e..455eadbbd0e 100644
--- a/tests/baselines/reference/symbolProperty33.symbols
+++ b/tests/baselines/reference/symbolProperty33.symbols
@@ -4,9 +4,9 @@ class C1 extends C2 {
 >C2 : Symbol(C2, Decl(symbolProperty33.ts, 4, 1))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty33.ts, 2, 16))
diff --git a/tests/baselines/reference/symbolProperty34.symbols b/tests/baselines/reference/symbolProperty34.symbols
index ab13908da9d..ff2a563ef3a 100644
--- a/tests/baselines/reference/symbolProperty34.symbols
+++ b/tests/baselines/reference/symbolProperty34.symbols
@@ -4,9 +4,9 @@ class C1 extends C2 {
 >C2 : Symbol(C2, Decl(symbolProperty34.ts, 4, 1))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty34.ts, 2, 16))
diff --git a/tests/baselines/reference/symbolProperty35.symbols b/tests/baselines/reference/symbolProperty35.symbols
index 9de473d5983..2558beac49d 100644
--- a/tests/baselines/reference/symbolProperty35.symbols
+++ b/tests/baselines/reference/symbolProperty35.symbols
@@ -3,18 +3,18 @@ interface I1 {
 >I1 : Symbol(I1, Decl(symbolProperty35.ts, 0, 0))
 
     [Symbol.toStringTag](): { x: string }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty35.ts, 1, 29))
 }
 interface I2 {
 >I2 : Symbol(I2, Decl(symbolProperty35.ts, 2, 1))
 
     [Symbol.toStringTag](): { x: number }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty35.ts, 4, 29))
 }
 
diff --git a/tests/baselines/reference/symbolProperty36.symbols b/tests/baselines/reference/symbolProperty36.symbols
index 9636c1c30f8..f91244bf7e5 100644
--- a/tests/baselines/reference/symbolProperty36.symbols
+++ b/tests/baselines/reference/symbolProperty36.symbols
@@ -3,12 +3,12 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty36.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: 0,
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.isConcatSpreadable]: 1
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty37.symbols b/tests/baselines/reference/symbolProperty37.symbols
index 392bbf52c8c..1f6f7f187d7 100644
--- a/tests/baselines/reference/symbolProperty37.symbols
+++ b/tests/baselines/reference/symbolProperty37.symbols
@@ -3,12 +3,12 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty37.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty38.symbols b/tests/baselines/reference/symbolProperty38.symbols
index 9bd7b40d9d0..b5eea169b56 100644
--- a/tests/baselines/reference/symbolProperty38.symbols
+++ b/tests/baselines/reference/symbolProperty38.symbols
@@ -3,15 +3,15 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty38.ts, 0, 0), Decl(symbolProperty38.ts, 2, 1))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
 interface I {
 >I : Symbol(I, Decl(symbolProperty38.ts, 0, 0), Decl(symbolProperty38.ts, 2, 1))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty39.symbols b/tests/baselines/reference/symbolProperty39.symbols
index 967bb9fd1d0..0e7ad86dd13 100644
--- a/tests/baselines/reference/symbolProperty39.symbols
+++ b/tests/baselines/reference/symbolProperty39.symbols
@@ -3,30 +3,30 @@ class C {
 >C : Symbol(C, Decl(symbolProperty39.ts, 0, 0))
 
     [Symbol.iterator](x: string): string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty39.ts, 1, 22))
 
     [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty39.ts, 2, 22))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty39.ts, 3, 22))
 
         return undefined;
 >undefined : Symbol(undefined)
     }
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty39.ts, 6, 22))
 
         return undefined;
diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols
index c1f7c82de7d..f525c68cc32 100644
--- a/tests/baselines/reference/symbolProperty4.symbols
+++ b/tests/baselines/reference/symbolProperty4.symbols
@@ -3,13 +3,13 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3))
 
     [Symbol()]: 0,
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     [Symbol()]() { },
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     get [Symbol()]() {
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols
index 9d546e7d426..71fa70280b7 100644
--- a/tests/baselines/reference/symbolProperty40.symbols
+++ b/tests/baselines/reference/symbolProperty40.symbols
@@ -3,21 +3,21 @@ class C {
 >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0))
 
     [Symbol.iterator](x: string): string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22))
 
     [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22))
 
         return undefined;
@@ -31,13 +31,13 @@ var c = new C;
 
 c[Symbol.iterator]("");
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 c[Symbol.iterator](0);
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols
index f0ef0692253..51eb63834eb 100644
--- a/tests/baselines/reference/symbolProperty41.symbols
+++ b/tests/baselines/reference/symbolProperty41.symbols
@@ -3,24 +3,24 @@ class C {
 >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0))
 
     [Symbol.iterator](x: string): { x: string };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22))
 >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35))
 
     [Symbol.iterator](x: "hello"): { x: string; hello: string };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22))
 >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36))
 >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22))
 
         return undefined;
@@ -34,13 +34,13 @@ var c = new C;
 
 c[Symbol.iterator]("");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 c[Symbol.iterator]("hello");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty42.symbols b/tests/baselines/reference/symbolProperty42.symbols
index eb6c8994f64..62ed7cc77d3 100644
--- a/tests/baselines/reference/symbolProperty42.symbols
+++ b/tests/baselines/reference/symbolProperty42.symbols
@@ -3,21 +3,21 @@ class C {
 >C : Symbol(C, Decl(symbolProperty42.ts, 0, 0))
 
     [Symbol.iterator](x: string): string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty42.ts, 1, 22))
 
     static [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty42.ts, 2, 29))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty42.ts, 3, 22))
 
         return undefined;
diff --git a/tests/baselines/reference/symbolProperty43.symbols b/tests/baselines/reference/symbolProperty43.symbols
index 8ef4496adfb..a7be6ab2068 100644
--- a/tests/baselines/reference/symbolProperty43.symbols
+++ b/tests/baselines/reference/symbolProperty43.symbols
@@ -3,14 +3,14 @@ class C {
 >C : Symbol(C, Decl(symbolProperty43.ts, 0, 0))
 
     [Symbol.iterator](x: string): string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty43.ts, 1, 22))
 
     [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty43.ts, 2, 22))
 }
diff --git a/tests/baselines/reference/symbolProperty44.symbols b/tests/baselines/reference/symbolProperty44.symbols
index 95e6ca38dfb..d95d7cd7cc4 100644
--- a/tests/baselines/reference/symbolProperty44.symbols
+++ b/tests/baselines/reference/symbolProperty44.symbols
@@ -3,16 +3,16 @@ class C {
 >C : Symbol(C, Decl(symbolProperty44.ts, 0, 0))
 
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols
index 0f42e37c5cf..e0ace066c31 100644
--- a/tests/baselines/reference/symbolProperty45.symbols
+++ b/tests/baselines/reference/symbolProperty45.symbols
@@ -3,16 +3,16 @@ class C {
 >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0))
 
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
     get [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty46.symbols b/tests/baselines/reference/symbolProperty46.symbols
index 6441ee99b70..14abb3c1723 100644
--- a/tests/baselines/reference/symbolProperty46.symbols
+++ b/tests/baselines/reference/symbolProperty46.symbols
@@ -3,30 +3,30 @@ class C {
 >C : Symbol(C, Decl(symbolProperty46.ts, 0, 0))
 
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
     // Should take a string
     set [Symbol.hasInstance](x) {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty46.ts, 5, 29))
     }
 }
 
 (new C)[Symbol.hasInstance] = 0;
 >C : Symbol(C, Decl(symbolProperty46.ts, 0, 0))
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
 (new C)[Symbol.hasInstance] = "";
 >C : Symbol(C, Decl(symbolProperty46.ts, 0, 0))
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty47.symbols b/tests/baselines/reference/symbolProperty47.symbols
index fac8d794bbb..01f50386868 100644
--- a/tests/baselines/reference/symbolProperty47.symbols
+++ b/tests/baselines/reference/symbolProperty47.symbols
@@ -3,30 +3,30 @@ class C {
 >C : Symbol(C, Decl(symbolProperty47.ts, 0, 0))
 
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
         return "";
     }
     // Should take a string
     set [Symbol.hasInstance](x: number) {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty47.ts, 5, 29))
     }
 }
 
 (new C)[Symbol.hasInstance] = 0;
 >C : Symbol(C, Decl(symbolProperty47.ts, 0, 0))
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
 (new C)[Symbol.hasInstance] = "";
 >C : Symbol(C, Decl(symbolProperty47.ts, 0, 0))
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols
index 1ca9150c347..56fa530d112 100644
--- a/tests/baselines/reference/symbolProperty5.symbols
+++ b/tests/baselines/reference/symbolProperty5.symbols
@@ -3,19 +3,19 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3))
 
     [Symbol.iterator]: 0,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.toPrimitive]() { },
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols
index 6df756a0277..7bdc0d6e36d 100644
--- a/tests/baselines/reference/symbolProperty50.symbols
+++ b/tests/baselines/reference/symbolProperty50.symbols
@@ -9,8 +9,8 @@ module M {
 >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24))
 
         [Symbol.iterator]() { }
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols
index 71384602b23..31d4edbb930 100644
--- a/tests/baselines/reference/symbolProperty51.symbols
+++ b/tests/baselines/reference/symbolProperty51.symbols
@@ -9,8 +9,8 @@ module M {
 >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21))
 
         [Symbol.iterator]() { }
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty52.symbols b/tests/baselines/reference/symbolProperty52.symbols
index 2366a96e221..43cb0309820 100644
--- a/tests/baselines/reference/symbolProperty52.symbols
+++ b/tests/baselines/reference/symbolProperty52.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty52.ts, 0, 3))
 
     [Symbol.nonsense]: 0
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 };
 
@@ -12,5 +12,5 @@ obj = {};
 
 obj[Symbol.nonsense];
 >obj : Symbol(obj, Decl(symbolProperty52.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty53.symbols b/tests/baselines/reference/symbolProperty53.symbols
index 15093663560..1a03b445673 100644
--- a/tests/baselines/reference/symbolProperty53.symbols
+++ b/tests/baselines/reference/symbolProperty53.symbols
@@ -3,15 +3,15 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty53.ts, 0, 3))
 
     [Symbol.for]: 0
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 };
 
 obj[Symbol.for];
 >obj : Symbol(obj, Decl(symbolProperty53.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty54.symbols b/tests/baselines/reference/symbolProperty54.symbols
index f04a679179d..897bcd569c1 100644
--- a/tests/baselines/reference/symbolProperty54.symbols
+++ b/tests/baselines/reference/symbolProperty54.symbols
@@ -3,8 +3,8 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty54.ts, 0, 3))
 
     [Symbol.prototype]: 0
->Symbol.prototype : Symbol(SymbolConstructor.prototype, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->prototype : Symbol(SymbolConstructor.prototype, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.prototype : Symbol(SymbolConstructor.prototype, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>prototype : Symbol(SymbolConstructor.prototype, Decl(lib.es6.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols
index e87120986ee..4b66fb9ecda 100644
--- a/tests/baselines/reference/symbolProperty55.symbols
+++ b/tests/baselines/reference/symbolProperty55.symbols
@@ -3,9 +3,9 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 };
 
@@ -14,13 +14,13 @@ module M {
 
     var Symbol: SymbolConstructor;
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator,
     // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol.
     obj[Symbol.iterator];
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols
index 492f28bd42c..e27457ece26 100644
--- a/tests/baselines/reference/symbolProperty56.symbols
+++ b/tests/baselines/reference/symbolProperty56.symbols
@@ -3,9 +3,9 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 };
 
diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols
index 05fa27816c9..c4ea9ec76c2 100644
--- a/tests/baselines/reference/symbolProperty57.symbols
+++ b/tests/baselines/reference/symbolProperty57.symbols
@@ -3,14 +3,14 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 };
 
 // Should give type 'any'.
 obj[Symbol["nonsense"]];
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty58.symbols b/tests/baselines/reference/symbolProperty58.symbols
index e4ed7399176..ee93c88a09d 100644
--- a/tests/baselines/reference/symbolProperty58.symbols
+++ b/tests/baselines/reference/symbolProperty58.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty58.ts ===
 interface SymbolConstructor {
->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(symbolProperty58.ts, 0, 0))
+>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(symbolProperty58.ts, 0, 0))
 
     foo: string;
 >foo : Symbol(SymbolConstructor.foo, Decl(symbolProperty58.ts, 0, 29))
@@ -11,6 +11,6 @@ var obj = {
 
     [Symbol.foo]: 0
 >Symbol.foo : Symbol(SymbolConstructor.foo, Decl(symbolProperty58.ts, 0, 29))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >foo : Symbol(SymbolConstructor.foo, Decl(symbolProperty58.ts, 0, 29))
 }
diff --git a/tests/baselines/reference/symbolProperty59.symbols b/tests/baselines/reference/symbolProperty59.symbols
index 1afa5596c2f..1268969ce36 100644
--- a/tests/baselines/reference/symbolProperty59.symbols
+++ b/tests/baselines/reference/symbolProperty59.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty59.ts, 0, 0))
 
     [Symbol.keyFor]: string;
->Symbol.keyFor : Symbol(SymbolConstructor.keyFor, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->keyFor : Symbol(SymbolConstructor.keyFor, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.keyFor : Symbol(SymbolConstructor.keyFor, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>keyFor : Symbol(SymbolConstructor.keyFor, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols
index 4bf20b1de55..8943edff7d7 100644
--- a/tests/baselines/reference/symbolProperty6.symbols
+++ b/tests/baselines/reference/symbolProperty6.symbols
@@ -3,24 +3,24 @@ class C {
 >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0))
 
     [Symbol.iterator] = 0;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.toPrimitive]() { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty7.symbols b/tests/baselines/reference/symbolProperty7.symbols
index c5db5645480..a19f6d16f3a 100644
--- a/tests/baselines/reference/symbolProperty7.symbols
+++ b/tests/baselines/reference/symbolProperty7.symbols
@@ -3,16 +3,16 @@ class C {
 >C : Symbol(C, Decl(symbolProperty7.ts, 0, 0))
 
     [Symbol()] = 0;
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     [Symbol()]: number;
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     [Symbol()]() { }
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     get [Symbol()]() {
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols
index e46c35b47be..9a94d3f1285 100644
--- a/tests/baselines/reference/symbolProperty8.symbols
+++ b/tests/baselines/reference/symbolProperty8.symbols
@@ -3,12 +3,12 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.es6.d.ts, --, --))
 
     [Symbol.toPrimitive]();
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty9.symbols b/tests/baselines/reference/symbolProperty9.symbols
index 8239fbb26ef..60aa9663695 100644
--- a/tests/baselines/reference/symbolProperty9.symbols
+++ b/tests/baselines/reference/symbolProperty9.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty9.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty9.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty9.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty9.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty9.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolType1.symbols b/tests/baselines/reference/symbolType1.symbols
index ded0dcff47b..1ba6bf448fd 100644
--- a/tests/baselines/reference/symbolType1.symbols
+++ b/tests/baselines/reference/symbolType1.symbols
@@ -1,17 +1,17 @@
 === tests/cases/conformance/es6/Symbols/symbolType1.ts ===
 Symbol() instanceof Symbol;
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 Symbol instanceof Symbol();
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 (Symbol() || {}) instanceof Object; // This one should be okay, it's a valid way of distinguishing types
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 Symbol instanceof (Symbol() || {});
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolType10.symbols b/tests/baselines/reference/symbolType10.symbols
index b242cbf366b..5d72856e227 100644
--- a/tests/baselines/reference/symbolType10.symbols
+++ b/tests/baselines/reference/symbolType10.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType10.ts ===
 var s = Symbol.for("bitwise");
 >s : Symbol(s, Decl(symbolType10.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s & s;
 >s : Symbol(s, Decl(symbolType10.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols
index 3c5fc1b61cc..4cf633413f7 100644
--- a/tests/baselines/reference/symbolType11.symbols
+++ b/tests/baselines/reference/symbolType11.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType11.ts ===
 var s = Symbol.for("logical");
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s && s;
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType12.symbols b/tests/baselines/reference/symbolType12.symbols
index 3cb844a8bfd..0367ac66fd5 100644
--- a/tests/baselines/reference/symbolType12.symbols
+++ b/tests/baselines/reference/symbolType12.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType12.ts ===
 var s = Symbol.for("assign");
 >s : Symbol(s, Decl(symbolType12.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 var str = "";
 >str : Symbol(str, Decl(symbolType12.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolType13.symbols b/tests/baselines/reference/symbolType13.symbols
index c9e22b5ed97..ee332848f5d 100644
--- a/tests/baselines/reference/symbolType13.symbols
+++ b/tests/baselines/reference/symbolType13.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolType13.ts ===
 var s = Symbol();
 >s : Symbol(s, Decl(symbolType13.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 var x: any;
 >x : Symbol(x, Decl(symbolType13.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolType14.symbols b/tests/baselines/reference/symbolType14.symbols
index d06a6279365..45620ffed20 100644
--- a/tests/baselines/reference/symbolType14.symbols
+++ b/tests/baselines/reference/symbolType14.symbols
@@ -1,4 +1,4 @@
 === tests/cases/conformance/es6/Symbols/symbolType14.ts ===
 new Symbol();
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolType15.symbols b/tests/baselines/reference/symbolType15.symbols
index f6e23073055..1c0cb19e2ca 100644
--- a/tests/baselines/reference/symbolType15.symbols
+++ b/tests/baselines/reference/symbolType15.symbols
@@ -4,7 +4,7 @@ var sym: symbol;
 
 var symObj: Symbol;
 >symObj : Symbol(symObj, Decl(symbolType15.ts, 1, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 symObj = sym;
 >symObj : Symbol(symObj, Decl(symbolType15.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols
index 3e5fb6e2157..f722f5fea2f 100644
--- a/tests/baselines/reference/symbolType16.symbols
+++ b/tests/baselines/reference/symbolType16.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolType16.ts ===
 interface Symbol {
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(symbolType16.ts, 0, 0))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(symbolType16.ts, 0, 0))
 
     newSymbolProp: number;
 >newSymbolProp : Symbol(Symbol.newSymbolProp, Decl(symbolType16.ts, 0, 18))
diff --git a/tests/baselines/reference/symbolType2.symbols b/tests/baselines/reference/symbolType2.symbols
index d0825e581b8..5931a71b32f 100644
--- a/tests/baselines/reference/symbolType2.symbols
+++ b/tests/baselines/reference/symbolType2.symbols
@@ -1,11 +1,11 @@
 === tests/cases/conformance/es6/Symbols/symbolType2.ts ===
 Symbol.isConcatSpreadable in {};
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.d.ts, --, --))
 
 "" in Symbol.toPrimitive;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolType3.symbols b/tests/baselines/reference/symbolType3.symbols
index 0403d9910aa..2d4a45d6da3 100644
--- a/tests/baselines/reference/symbolType3.symbols
+++ b/tests/baselines/reference/symbolType3.symbols
@@ -1,22 +1,22 @@
 === tests/cases/conformance/es6/Symbols/symbolType3.ts ===
 var s = Symbol();
 >s : Symbol(s, Decl(symbolType3.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 delete Symbol.iterator;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es6.d.ts, --, --))
 
 void Symbol.toPrimitive;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.es6.d.ts, --, --))
 
 typeof Symbol.toStringTag;
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es6.d.ts, --, --))
 
 ++s;
 >s : Symbol(s, Decl(symbolType3.ts, 0, 3))
@@ -25,17 +25,17 @@ typeof Symbol.toStringTag;
 >s : Symbol(s, Decl(symbolType3.ts, 0, 3))
 
 + Symbol();
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 - Symbol();
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 ~ Symbol();
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 ! Symbol();
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
 +(Symbol() || 0);
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolType4.symbols b/tests/baselines/reference/symbolType4.symbols
index b1fd89595cf..e668afd6fa3 100644
--- a/tests/baselines/reference/symbolType4.symbols
+++ b/tests/baselines/reference/symbolType4.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType4.ts ===
 var s = Symbol.for("postfix");
 >s : Symbol(s, Decl(symbolType4.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s++;
 >s : Symbol(s, Decl(symbolType4.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType5.symbols b/tests/baselines/reference/symbolType5.symbols
index b1ccf915bd6..aa902bb6684 100644
--- a/tests/baselines/reference/symbolType5.symbols
+++ b/tests/baselines/reference/symbolType5.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType5.ts ===
 var s = Symbol.for("multiply");
 >s : Symbol(s, Decl(symbolType5.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s * s;
 >s : Symbol(s, Decl(symbolType5.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType6.symbols b/tests/baselines/reference/symbolType6.symbols
index cc934b28337..4d823c8907a 100644
--- a/tests/baselines/reference/symbolType6.symbols
+++ b/tests/baselines/reference/symbolType6.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType6.ts ===
 var s = Symbol.for("add");
 >s : Symbol(s, Decl(symbolType6.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 var a: any;
 >a : Symbol(a, Decl(symbolType6.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolType7.symbols b/tests/baselines/reference/symbolType7.symbols
index ccd9d8ef449..f7733ac1936 100644
--- a/tests/baselines/reference/symbolType7.symbols
+++ b/tests/baselines/reference/symbolType7.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType7.ts ===
 var s = Symbol.for("shift");
 >s : Symbol(s, Decl(symbolType7.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s << s;
 >s : Symbol(s, Decl(symbolType7.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType8.symbols b/tests/baselines/reference/symbolType8.symbols
index 32407ecbfd1..00abf89c26a 100644
--- a/tests/baselines/reference/symbolType8.symbols
+++ b/tests/baselines/reference/symbolType8.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType8.ts ===
 var s = Symbol.for("compare");
 >s : Symbol(s, Decl(symbolType8.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s < s;
 >s : Symbol(s, Decl(symbolType8.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType9.symbols b/tests/baselines/reference/symbolType9.symbols
index 48730edb891..4388254d569 100644
--- a/tests/baselines/reference/symbolType9.symbols
+++ b/tests/baselines/reference/symbolType9.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType9.ts ===
 var s = Symbol.for("equal");
 >s : Symbol(s, Decl(symbolType9.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
->Symbol : Symbol(Symbol, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --))
->for : Symbol(SymbolConstructor.for, Decl(lib.es2015.symbol.d.ts, --, --))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.es6.d.ts, --, --))
 
 s == s;
 >s : Symbol(s, Decl(symbolType9.ts, 0, 3))
diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.symbols b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.symbols
index 85019711153..c0eaabecfd6 100644
--- a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.symbols
+++ b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.symbols
@@ -8,9 +8,9 @@ export = packageExport;
 
 === tests/cases/compiler/index.ts ===
 import("package").then(({default: foo}) => foo(42));
->import("package").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>import("package").then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >"package" : Symbol("tests/cases/compiler/node_modules/package/index", Decl(index.d.ts, 0, 0))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es6.d.ts, --, --))
 >default : Symbol(default)
 >foo : Symbol(foo, Decl(index.ts, 0, 25))
 >foo : Symbol(foo, Decl(index.ts, 0, 25))
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
index 320c0e74479..4f931dbb96a 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
@@ -12,7 +12,7 @@ function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, x: T): T;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 2, 18))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 2, 21))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 2, 56))
 >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 2, 69))
@@ -23,7 +23,7 @@ function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, h: FuncTyp
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 0, 48), Decl(taggedTemplateContextualTyping1.ts, 2, 79), Decl(taggedTemplateContextualTyping1.ts, 3, 92))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 3, 21))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 3, 56))
 >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0))
 >h : Symbol(h, Decl(taggedTemplateContextualTyping1.ts, 3, 69))
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
index 8c9459638d0..950a39cfccc 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
@@ -21,7 +21,7 @@ type FuncType2 = (x: <S, T>(p: T) => T) => typeof x;
 function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 3, 18))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 3, 53))
 >FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 3, 67))
@@ -29,7 +29,7 @@ function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number):
 function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 1, 52), Decl(taggedTemplateContextualTyping2.ts, 3, 87), Decl(taggedTemplateContextualTyping2.ts, 4, 101))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 4, 18))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 4, 53))
 >FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 0, 49))
 >h : Symbol(h, Decl(taggedTemplateContextualTyping2.ts, 4, 67))
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.symbols b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.symbols
index 6594dcf1afa..f4170c38d26 100644
--- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.symbols
@@ -293,7 +293,7 @@ interface A92 {
 
     z?: Date;
 >z : Symbol(A92.z, Decl(taggedTemplateStringsTypeArgumentInference.ts, 70, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
@@ -302,7 +302,7 @@ var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y:
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateStringsTypeArgumentInference.ts, 74, 43))
 >z : Symbol(z, Decl(taggedTemplateStringsTypeArgumentInference.ts, 74, 49))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsTypeArgumentInference.ts, 74, 71))
 >y : Symbol(y, Decl(taggedTemplateStringsTypeArgumentInference.ts, 74, 77))
 
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.symbols b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.symbols
index bafb4ac9837..79f294e0d92 100644
--- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.symbols
@@ -14,7 +14,7 @@ function noGenericParams<T>(n: TemplateStringsArray) { }
 >noGenericParams : Symbol(noGenericParams, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 2, 12))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 5, 25))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 5, 28))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 
 noGenericParams ``;
 >noGenericParams : Symbol(noGenericParams, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 2, 12))
@@ -36,7 +36,7 @@ function someGenerics1b<T, U>(n: TemplateStringsArray, m: U) { }
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 12, 24))
 >U : Symbol(U, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 12, 26))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 12, 30))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >m : Symbol(m, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 12, 54))
 >U : Symbol(U, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 12, 26))
 
@@ -48,7 +48,7 @@ function someGenerics2a<T>(strs: TemplateStringsArray, n: (x: T) => void) { }
 >someGenerics2a : Symbol(someGenerics2a, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 13, 22))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 16, 24))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 16, 27))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 16, 54))
 >x : Symbol(x, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 16, 59))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 16, 24))
@@ -63,7 +63,7 @@ function someGenerics2b<T, U>(strs: TemplateStringsArray, n: (x: T, y: U) => voi
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 19, 24))
 >U : Symbol(U, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 19, 26))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 19, 30))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 19, 57))
 >x : Symbol(x, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 19, 62))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 19, 24))
@@ -81,7 +81,7 @@ function someGenerics3<T>(strs: TemplateStringsArray, producer: () => T) { }
 >someGenerics3 : Symbol(someGenerics3, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 20, 50))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 23, 23))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 23, 26))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >producer : Symbol(producer, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 23, 53))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 23, 23))
 
@@ -101,7 +101,7 @@ function someGenerics4<T, U>(strs: TemplateStringsArray, n: T, f: (x: U) => void
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 29, 23))
 >U : Symbol(U, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 29, 25))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 29, 29))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 29, 56))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 29, 23))
 >f : Symbol(f, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 29, 62))
@@ -123,7 +123,7 @@ function someGenerics5<U, T>(strs: TemplateStringsArray, n: T, f: (x: U) => void
 >U : Symbol(U, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 35, 23))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 35, 25))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 35, 29))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 35, 56))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 35, 25))
 >f : Symbol(f, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 35, 62))
@@ -144,7 +144,7 @@ function someGenerics6<A>(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A)
 >someGenerics6 : Symbol(someGenerics6, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 38, 31))
 >A : Symbol(A, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 41, 23))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 41, 26))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 41, 53))
 >a : Symbol(a, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 41, 58))
 >A : Symbol(A, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 41, 23))
@@ -192,7 +192,7 @@ function someGenerics7<A, B, C>(strs: TemplateStringsArray, a: (a: A) => A, b: (
 >B : Symbol(B, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 47, 25))
 >C : Symbol(C, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 47, 28))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 47, 32))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 47, 59))
 >a : Symbol(a, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 47, 64))
 >A : Symbol(A, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 47, 23))
@@ -238,7 +238,7 @@ function someGenerics8<T>(strs: TemplateStringsArray, n: T): T { return n; }
 >someGenerics8 : Symbol(someGenerics8, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 50, 76))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 53, 23))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 53, 26))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 53, 53))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 53, 23))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 53, 23))
@@ -257,7 +257,7 @@ function someGenerics9<T>(strs: TemplateStringsArray, a: T, b: T, c: T): T {
 >someGenerics9 : Symbol(someGenerics9, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 55, 26))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 58, 23))
 >strs : Symbol(strs, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 58, 26))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >a : Symbol(a, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 58, 53))
 >T : Symbol(T, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 58, 23))
 >b : Symbol(b, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 58, 59))
@@ -293,7 +293,7 @@ interface A92 {
 
     z?: Date;
 >z : Symbol(A92.z, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 70, 14))
->Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 }
 
 var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
@@ -302,7 +302,7 @@ var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y:
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 74, 43))
 >z : Symbol(z, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 74, 49))
->Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 74, 71))
 >y : Symbol(y, Decl(taggedTemplateStringsTypeArgumentInferenceES6.ts, 74, 77))
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.symbols
index 5ec23bae79a..848ed7682f8 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.symbols
@@ -4,7 +4,7 @@ interface I {
 
     (stringParts: TemplateStringsArray, ...rest: boolean[]): I;
 >stringParts : Symbol(stringParts, Decl(taggedTemplateStringsWithIncompatibleTypedTagsES6.ts, 1, 5))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >rest : Symbol(rest, Decl(taggedTemplateStringsWithIncompatibleTypedTagsES6.ts, 1, 39))
 >I : Symbol(I, Decl(taggedTemplateStringsWithIncompatibleTypedTagsES6.ts, 0, 0))
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols
index 0d163daa640..1a81f4c36a0 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols
@@ -4,7 +4,7 @@ interface I {
 
     (strs: TemplateStringsArray, ...subs: number[]): I;
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 5))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >subs : Symbol(subs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 32))
 >I : Symbol(I, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 0, 0))
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.symbols
index fad61bd5e7d..2f45654ce62 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.symbols
@@ -2,25 +2,25 @@
 function foo(strs: TemplateStringsArray): number;
 >foo : Symbol(foo, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 49), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 1, 60), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 72), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 67))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 
 function foo(strs: TemplateStringsArray, x: number): string;
 >foo : Symbol(foo, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 49), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 1, 60), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 72), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 67))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 1, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 1, 40))
 
 function foo(strs: TemplateStringsArray, x: number, y: number): boolean;
 >foo : Symbol(foo, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 49), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 1, 60), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 72), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 67))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 40))
 >y : Symbol(y, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 51))
 
 function foo(strs: TemplateStringsArray, x: number, y: string): {};
 >foo : Symbol(foo, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 0, 49), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 1, 60), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 2, 72), Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 67))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 40))
 >y : Symbol(y, Decl(taggedTemplateStringsWithOverloadResolution1_ES6.ts, 3, 51))
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols
index 9cc79f2596f..c124db958da 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols
@@ -2,7 +2,7 @@
 function foo1(strs: TemplateStringsArray, x: number): string;
 >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 1, 49))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 14))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 41))
 
 function foo1(strs: string[], x: number): number;
@@ -34,7 +34,7 @@ function foo2(strs: string[], x: number): number;
 function foo2(strs: TemplateStringsArray, x: number): string;
 >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 61))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 14))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 41))
 
 function foo2(...stuff: any[]): any {
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.symbols
index c9dc30d3a2d..07b5228bae0 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.symbols
@@ -47,7 +47,7 @@ function fn2() { return undefined; }
 
 var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
 >d1 : Symbol(d1, Decl(taggedTemplateStringsWithOverloadResolution3.ts, 14, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn2 : Symbol(fn2, Decl(taggedTemplateStringsWithOverloadResolution3.ts, 8, 14), Decl(taggedTemplateStringsWithOverloadResolution3.ts, 10, 71), Decl(taggedTemplateStringsWithOverloadResolution3.ts, 11, 64))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.symbols
index 01c9696c312..fb19ebbb4c9 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.symbols
@@ -3,13 +3,13 @@
 function fn1(strs: TemplateStringsArray, s: string): string;
 >fn1 : Symbol(fn1, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 1, 60), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 2, 60))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 1, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 1, 40))
 
 function fn1(strs: TemplateStringsArray, n: number): number;
 >fn1 : Symbol(fn1, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 1, 60), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 2, 60))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 2, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 2, 40))
 
 function fn1() { return null; }
@@ -27,7 +27,7 @@ fn1 `${ {} }`; // Error
 function fn2(strs: TemplateStringsArray, s: string, n: number): number;
 >fn2 : Symbol(fn2, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 8, 14), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 10, 71), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 64))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 10, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 10, 40))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 10, 51))
 
@@ -35,7 +35,7 @@ function fn2<T>(strs: TemplateStringsArray, n: number, t: T): T;
 >fn2 : Symbol(fn2, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 8, 14), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 10, 71), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 64))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 13))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 16))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 43))
 >t : Symbol(t, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 54))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 13))
@@ -47,7 +47,7 @@ function fn2() { return undefined; }
 
 var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
 >d1 : Symbol(d1, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 14, 3))
->Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >fn2 : Symbol(fn2, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 8, 14), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 10, 71), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 11, 64))
 >undefined : Symbol(undefined)
 
@@ -75,7 +75,7 @@ function fn3<T>(strs: TemplateStringsArray, n: T): string;
 >fn3 : Symbol(fn3, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 24, 20), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 27, 58), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 73), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 76))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 27, 13))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 27, 16))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 27, 43))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 27, 13))
 
@@ -84,7 +84,7 @@ function fn3<T, U>(strs: TemplateStringsArray, s: string, t: T, u: U): U;
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 13))
 >U : Symbol(U, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 15))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 19))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >s : Symbol(s, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 46))
 >t : Symbol(t, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 57))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 28, 13))
@@ -98,7 +98,7 @@ function fn3<T, U, V>(strs: TemplateStringsArray, v: V, u: U, t: T): number;
 >U : Symbol(U, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 15))
 >V : Symbol(V, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 18))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 22))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >v : Symbol(v, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 49))
 >V : Symbol(V, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 18))
 >u : Symbol(u, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 29, 55))
@@ -147,7 +147,7 @@ function fn4<T extends string, U extends number>(strs: TemplateStringsArray, n:
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 13))
 >U : Symbol(U, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 30))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 49))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 76))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 13))
 >m : Symbol(m, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 82))
@@ -158,7 +158,7 @@ function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n:
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 13))
 >U : Symbol(U, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 30))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 49))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 76))
 >T : Symbol(T, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 13))
 >m : Symbol(m, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 82))
@@ -167,7 +167,7 @@ function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n:
 function fn4(strs: TemplateStringsArray)
 >fn4 : Symbol(fn4, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 43, 7), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 89), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 89), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 48, 40))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 48, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 
 function fn4() { }
 >fn4 : Symbol(fn4, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 43, 7), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 46, 89), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 47, 89), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 48, 40))
@@ -201,14 +201,14 @@ fn4 `${ null }${ true }`;
 function fn5(strs: TemplateStringsArray, f: (n: string) => void): string;
 >fn5 : Symbol(fn5, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 62, 25), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 65, 73), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 66, 73))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 65, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 65, 40))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 65, 45))
 
 function fn5(strs: TemplateStringsArray, f: (n: number) => void): number;
 >fn5 : Symbol(fn5, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 62, 25), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 65, 73), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 66, 73))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 66, 13))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 66, 40))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 66, 45))
 
@@ -224,8 +224,8 @@ fn5 `${ (n) => n.toFixed() }`; // will error; 'n' should have type 'string'.
 fn5 `${ (n) => n.substr(0) }`;
 >fn5 : Symbol(fn5, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 62, 25), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 65, 73), Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 66, 73))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 69, 9))
->n.substr : Symbol(String.substr, Decl(lib.es5.d.ts, --, --))
+>n.substr : Symbol(String.substr, Decl(lib.es6.d.ts, --, --))
 >n : Symbol(n, Decl(taggedTemplateStringsWithOverloadResolution3_ES6.ts, 69, 9))
->substr : Symbol(String.substr, Decl(lib.es5.d.ts, --, --))
+>substr : Symbol(String.substr, Decl(lib.es6.d.ts, --, --))
 
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols
index f7f9c62d492..64be0db1a92 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols
@@ -4,7 +4,7 @@ interface I {
 
     (stringParts: TemplateStringsArray, ...rest: number[]): I;
 >stringParts : Symbol(stringParts, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 5))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >rest : Symbol(rest, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 39))
 >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 0, 0))
 
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.symbols
index 4735c33e421..7daa576a25e 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.symbols
index f0cf4b20af3..3262b1dcad5 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.symbols
index 4f41bcd748e..946026220ea 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteTemplateExpressions1.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteTemplateExpressions1.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteTemplateExpressions1.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteTemplateExpressions1.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.symbols
index 90316388c50..051a8a2706f 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteTemplateExpressions2.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteTemplateExpressions2.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteTemplateExpressions2.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteTemplateExpressions2.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.symbols
index 35629254802..a51594b3772 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteTemplateExpressions3.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteTemplateExpressions3.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteTemplateExpressions3.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteTemplateExpressions3.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.symbols
index ba814b71c97..88dab945db0 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteTemplateExpressions4.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteTemplateExpressions4.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteTemplateExpressions4.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteTemplateExpressions4.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.symbols
index d9cc96fd93f..9152de0026b 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteTemplateExpressions5.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteTemplateExpressions5.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteTemplateExpressions5.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteTemplateExpressions5.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.symbols b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.symbols
index 6a18e12c08f..608273563aa 100644
--- a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.symbols
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.symbols
@@ -2,7 +2,7 @@
 function f(x: TemplateStringsArray, y: string, z: string) {
 >f : Symbol(f, Decl(taggedTemplatesWithIncompleteTemplateExpressions6.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplatesWithIncompleteTemplateExpressions6.ts, 0, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --))
 >y : Symbol(y, Decl(taggedTemplatesWithIncompleteTemplateExpressions6.ts, 0, 35))
 >z : Symbol(z, Decl(taggedTemplatesWithIncompleteTemplateExpressions6.ts, 0, 46))
 }
diff --git a/tests/baselines/reference/templateStringInInstanceOfES6.symbols b/tests/baselines/reference/templateStringInInstanceOfES6.symbols
index bc6379c6ef4..9580d7c069d 100644
--- a/tests/baselines/reference/templateStringInInstanceOfES6.symbols
+++ b/tests/baselines/reference/templateStringInInstanceOfES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringInInstanceOfES6.ts ===
 var x = `abc${ 0 }def` instanceof String;
 >x : Symbol(x, Decl(templateStringInInstanceOfES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.symbols
index 9bd564f089e..ab2e5d8094e 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedInstanceOfES6.ts ===
 var x = `abc${ "hello" instanceof String }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedInstanceOfES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
index 9c29590b783..b597bc5e6d7 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts ===
 var x = `abc${ new String("Hi") }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more)
+>String : Symbol(String, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --) ... and 1 more)
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols
index df10fbfca6d..06a1acd210b 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts ===
 var x = `abc${ +Infinity }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedUnaryPlusES6.ts, 0, 3))
->Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --))
+>Infinity : Symbol(Infinity, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols b/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols
index 803705609a1..4638a3813b9 100644
--- a/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols
+++ b/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts ===
 `abc${0}abc`.indexOf(`abc`);
->`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.es5.d.ts, --, --))
->indexOf : Symbol(String.indexOf, Decl(lib.es5.d.ts, --, --))
+>`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.es6.d.ts, --, --))
+>indexOf : Symbol(String.indexOf, Decl(lib.es6.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.symbols b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.symbols
index f65f949fcb9..225f7c9b122 100644
--- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.symbols
+++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.symbols
@@ -1,12 +1,12 @@
 === tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts ===
 class TemplateStringsArray {
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --), Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 0, 0))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --), Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 0, 0))
 }
 
 function f(x: TemplateStringsArray, y: number, z: number) {
 >f : Symbol(f, Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 1, 1))
 >x : Symbol(x, Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 3, 11))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --), Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 0, 0))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es6.d.ts, --, --), Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 0, 0))
 >y : Symbol(y, Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 3, 35))
 >z : Symbol(z, Decl(templateStringsArrayTypeRedefinedInES6Mode.ts, 3, 46))
 }
diff --git a/tests/baselines/reference/thisBinding2.symbols b/tests/baselines/reference/thisBinding2.symbols
index f8436f5248b..3404ad69473 100644
--- a/tests/baselines/reference/thisBinding2.symbols
+++ b/tests/baselines/reference/thisBinding2.symbols
@@ -33,7 +33,7 @@ class C {
     }  
 }
 declare function setTimeout(expression: any, msec?: number, language?: any): number;
->setTimeout : Symbol(setTimeout, Decl(thisBinding2.ts, 12, 1))
+>setTimeout : Symbol(setTimeout, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisBinding2.ts, 12, 1))
 >expression : Symbol(expression, Decl(thisBinding2.ts, 13, 28))
 >msec : Symbol(msec, Decl(thisBinding2.ts, 13, 44))
 >language : Symbol(language, Decl(thisBinding2.ts, 13, 59))
@@ -48,7 +48,7 @@ var messenger = {
 >start : Symbol(start, Decl(thisBinding2.ts, 15, 27))
 
         return setTimeout(() => { var x = this.message; }, 3000);
->setTimeout : Symbol(setTimeout, Decl(thisBinding2.ts, 12, 1))
+>setTimeout : Symbol(setTimeout, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisBinding2.ts, 12, 1))
 >x : Symbol(x, Decl(thisBinding2.ts, 17, 37))
 >this.message : Symbol(message, Decl(thisBinding2.ts, 14, 17))
 >this : Symbol(messenger, Decl(thisBinding2.ts, 14, 15))
diff --git a/tests/baselines/reference/thisBinding2.types b/tests/baselines/reference/thisBinding2.types
index 4889e6d3b33..72cf2d07283 100644
--- a/tests/baselines/reference/thisBinding2.types
+++ b/tests/baselines/reference/thisBinding2.types
@@ -46,7 +46,7 @@ class C {
     }  
 }
 declare function setTimeout(expression: any, msec?: number, language?: any): number;
->setTimeout : (expression: any, msec?: number, language?: any) => number
+>setTimeout : { (handler: (...args: any[]) => void, timeout: number): number; (handler: any, timeout?: any, ...args: any[]): number; (expression: any, msec?: number, language?: any): number; }
 >expression : any
 >msec : number
 >language : any
@@ -65,7 +65,7 @@ var messenger = {
 
         return setTimeout(() => { var x = this.message; }, 3000);
 >setTimeout(() => { var x = this.message; }, 3000) : number
->setTimeout : (expression: any, msec?: number, language?: any) => number
+>setTimeout : { (handler: (...args: any[]) => void, timeout: number): number; (handler: any, timeout?: any, ...args: any[]): number; (expression: any, msec?: number, language?: any): number; }
 >() => { var x = this.message; } : () => void
 >x : string
 >this.message : string
diff --git a/tests/baselines/reference/thisTypeInClasses.symbols b/tests/baselines/reference/thisTypeInClasses.symbols
index 0f98f013b01..df8ffe927df 100644
--- a/tests/baselines/reference/thisTypeInClasses.symbols
+++ b/tests/baselines/reference/thisTypeInClasses.symbols
@@ -41,11 +41,11 @@ class C3 {
 
     c: this | Date;
 >c : Symbol(C3.c, Decl(thisTypeInClasses.ts, 16, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d: this & Date;
 >d : Symbol(C3.d, Decl(thisTypeInClasses.ts, 17, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     e: (((this)));
 >e : Symbol(C3.e, Decl(thisTypeInClasses.ts, 18, 19))
diff --git a/tests/baselines/reference/thisTypeInInterfaces.symbols b/tests/baselines/reference/thisTypeInInterfaces.symbols
index 286447a7083..3b02bbe3588 100644
--- a/tests/baselines/reference/thisTypeInInterfaces.symbols
+++ b/tests/baselines/reference/thisTypeInInterfaces.symbols
@@ -46,11 +46,11 @@ interface I3 {
 
     c: this | Date;
 >c : Symbol(I3.c, Decl(thisTypeInInterfaces.ts, 18, 20))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d: this & Date;
 >d : Symbol(I3.d, Decl(thisTypeInInterfaces.ts, 19, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     e: (((this)));
 >e : Symbol(I3.e, Decl(thisTypeInInterfaces.ts, 20, 19))
diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols
index e4d09aeb0e8..0aee3630654 100644
--- a/tests/baselines/reference/throwStatements.symbols
+++ b/tests/baselines/reference/throwStatements.symbols
@@ -72,7 +72,7 @@ throw aString;
 
 var aDate = new Date(12);
 >aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw aDate;
 >aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3))
@@ -202,7 +202,7 @@ throw [];
 throw ['a', ['b']];
 throw /[a-z]/;
 throw new Date();
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw new C();
 >C : Symbol(C, Decl(throwStatements.ts, 4, 1))
diff --git a/tests/baselines/reference/tooManyTypeParameters1.symbols b/tests/baselines/reference/tooManyTypeParameters1.symbols
index c7d7cf3ae38..761028be41c 100644
--- a/tests/baselines/reference/tooManyTypeParameters1.symbols
+++ b/tests/baselines/reference/tooManyTypeParameters1.symbols
@@ -20,8 +20,8 @@ class C<T> {}
 var c = new C<Date,Date>();
 >c : Symbol(c, Decl(tooManyTypeParameters1.ts, 7, 3))
 >C : Symbol(C, Decl(tooManyTypeParameters1.ts, 4, 19))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 interface I<T> {}
 >I : Symbol(I, Decl(tooManyTypeParameters1.ts, 7, 27))
diff --git a/tests/baselines/reference/twoGenericInterfacesWithDifferentConstraints.symbols b/tests/baselines/reference/twoGenericInterfacesWithDifferentConstraints.symbols
index 46b0d397e09..22323979217 100644
--- a/tests/baselines/reference/twoGenericInterfacesWithDifferentConstraints.symbols
+++ b/tests/baselines/reference/twoGenericInterfacesWithDifferentConstraints.symbols
@@ -2,7 +2,7 @@
 interface A<T extends Date> {
 >A : Symbol(A, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 0, 0), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 2, 1))
 >T : Symbol(T, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 0, 12), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 4, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     x: T;
 >x : Symbol(A.x, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 0, 29))
@@ -26,7 +26,7 @@ module M {
 >B : Symbol(B, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 8, 10), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 11, 5))
 >T : Symbol(T, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 9, 16), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 13, 16))
 >A : Symbol(A, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 0, 0), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 2, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         x: T;
 >x : Symbol(B.x, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 9, 36))
@@ -50,7 +50,7 @@ module M2 {
     interface A<T extends Date> {
 >A : Symbol(A, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 18, 11))
 >T : Symbol(T, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 19, 16))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         x: T;
 >x : Symbol(A.x, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 19, 33))
@@ -78,7 +78,7 @@ module M3 {
     export interface A<T extends Date> {
 >A : Symbol(A, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 30, 11), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 36, 11))
 >T : Symbol(T, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 31, 23), Decl(twoGenericInterfacesWithDifferentConstraints.ts, 37, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         x: T;
 >x : Symbol(A.x, Decl(twoGenericInterfacesWithDifferentConstraints.ts, 31, 40))
diff --git a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols
index b93de8e55ce..34900916a56 100644
--- a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols
+++ b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols
@@ -19,8 +19,8 @@ interface A {
     foo(x: Date): Date;
 >foo : Symbol(A.foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 2, 13), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 3, 27), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 7, 13))
 >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface B<T> {
@@ -45,12 +45,12 @@ interface B<T> {
 >foo : Symbol(B.foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 12, 22), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 20))
 >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 8))
 >T : Symbol(T, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 12), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: Date): string;
 >foo : Symbol(B.foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 12, 22), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 20))
 >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 18, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var b: B<boolean>;
@@ -100,7 +100,7 @@ interface C<T, U> {
 var c: C<boolean, Date>;
 >c : Symbol(c, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 34, 3))
 >C : Symbol(C, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 22, 20), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 28, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r2 = c.foo(1, 2); // number
 >r2 : Symbol(r2, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 35, 3))
@@ -150,7 +150,7 @@ interface D<T, U> {
 var d: D<boolean, Date>;
 >d : Symbol(d, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 48, 3))
 >D : Symbol(D, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 35, 21), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 42, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r3 = d.foo(1, 1); // boolean, last definition wins
 >r3 : Symbol(r3, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 49, 3))
diff --git a/tests/baselines/reference/typeArgumentConstraintResolution1.symbols b/tests/baselines/reference/typeArgumentConstraintResolution1.symbols
index 66868e80c73..3f32ab58f3b 100644
--- a/tests/baselines/reference/typeArgumentConstraintResolution1.symbols
+++ b/tests/baselines/reference/typeArgumentConstraintResolution1.symbols
@@ -2,7 +2,7 @@
 function foo1<T extends Date>(test: T);
 >foo1 : Symbol(foo1, Decl(typeArgumentConstraintResolution1.ts, 0, 0), Decl(typeArgumentConstraintResolution1.ts, 0, 39), Decl(typeArgumentConstraintResolution1.ts, 1, 46))
 >T : Symbol(T, Decl(typeArgumentConstraintResolution1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >test : Symbol(test, Decl(typeArgumentConstraintResolution1.ts, 0, 30))
 >T : Symbol(T, Decl(typeArgumentConstraintResolution1.ts, 0, 14))
 
@@ -20,14 +20,14 @@ function foo1<T extends String>(test: any) { }
 
 foo1<Date>(""); // should error
 >foo1 : Symbol(foo1, Decl(typeArgumentConstraintResolution1.ts, 0, 0), Decl(typeArgumentConstraintResolution1.ts, 0, 39), Decl(typeArgumentConstraintResolution1.ts, 1, 46))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 
 
 function foo2<T extends Date>(test: T): T;
 >foo2 : Symbol(foo2, Decl(typeArgumentConstraintResolution1.ts, 3, 15), Decl(typeArgumentConstraintResolution1.ts, 7, 42), Decl(typeArgumentConstraintResolution1.ts, 8, 49))
 >T : Symbol(T, Decl(typeArgumentConstraintResolution1.ts, 7, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >test : Symbol(test, Decl(typeArgumentConstraintResolution1.ts, 7, 30))
 >T : Symbol(T, Decl(typeArgumentConstraintResolution1.ts, 7, 14))
 >T : Symbol(T, Decl(typeArgumentConstraintResolution1.ts, 7, 14))
@@ -47,5 +47,5 @@ function foo2<T extends String>(test: any): any { return null; }
 
 foo2<Date>(""); // Type Date does not satisfy the constraint 'Number' for type parameter 'T extends Number'
 >foo2 : Symbol(foo2, Decl(typeArgumentConstraintResolution1.ts, 3, 15), Decl(typeArgumentConstraintResolution1.ts, 7, 42), Decl(typeArgumentConstraintResolution1.ts, 8, 49))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeArgumentInference.symbols b/tests/baselines/reference/typeArgumentInference.symbols
index 001fb619e00..4b37b4ca6f8 100644
--- a/tests/baselines/reference/typeArgumentInference.symbols
+++ b/tests/baselines/reference/typeArgumentInference.symbols
@@ -112,7 +112,7 @@ someGenerics3(() => '');
 
 someGenerics3<Date>(() => undefined);
 >someGenerics3 : Symbol(someGenerics3, Decl(typeArgumentInference.ts, 26, 58))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 someGenerics3<number>(() => 3);
@@ -317,7 +317,7 @@ interface A92 {
 
     z?: Date;
 >z : Symbol(A92.z, Decl(typeArgumentInference.ts, 78, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 var a9e = someGenerics9(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
 >a9e : Symbol(a9e, Decl(typeArgumentInference.ts, 81, 3), Decl(typeArgumentInference.ts, 82, 3))
@@ -325,7 +325,7 @@ var a9e = someGenerics9(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(typeArgumentInference.ts, 81, 36))
 >z : Symbol(z, Decl(typeArgumentInference.ts, 81, 42))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeArgumentInference.ts, 81, 61))
 >y : Symbol(y, Decl(typeArgumentInference.ts, 81, 67))
 
@@ -339,7 +339,7 @@ var a9f = someGenerics9<A92>(undefined, { x: 6, z: new Date() }, { x: 6, y: '' }
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(typeArgumentInference.ts, 83, 41))
 >z : Symbol(z, Decl(typeArgumentInference.ts, 83, 47))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeArgumentInference.ts, 83, 66))
 >y : Symbol(y, Decl(typeArgumentInference.ts, 83, 72))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
index c9ef38b3c5c..7fe379bdcf2 100644
--- a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
@@ -3,7 +3,7 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType1.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType1.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
index f257b3596ba..75664a7b14e 100644
--- a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
@@ -3,14 +3,14 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType2.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType2.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
     function inner<U extends Iterable<T>>() {
 >inner : Symbol(inner, Decl(typeArgumentInferenceApparentType2.ts, 0, 46))
 >U : Symbol(U, Decl(typeArgumentInferenceApparentType2.ts, 1, 19))
->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.es6.d.ts, --, --))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
         var u: U;
diff --git a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
index ef0c93f20cd..ef02b0bb574 100644
--- a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
@@ -1,5 +1,4 @@
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(25,35): error TS2345: Argument of type '3' is not assignable to parameter of type 'string'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(51,19): error TS2304: Cannot find name 'Window'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(61,39): error TS2345: Argument of type '(x: string) => string' is not assignable to parameter of type '(x: number) => void'.
   Types of parameters 'x' and 'x' are incompatible.
     Type 'number' is not assignable to type 'string'.
@@ -10,15 +9,12 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
   Types of parameters 'n' and 'b' are incompatible.
     Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(106,33): error TS2345: Argument of type '0' is not assignable to parameter of type '""'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(118,9): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,51): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(121,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts 119:4, but here has type '{}'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(122,56): error TS2304: Cannot find name 'window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(121,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts 119:4, but here has type '{}'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(122,74): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
 
 
-==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts (11 errors) ====
+==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts (7 errors) ====
     // Generic call with no parameters
     interface NoParams {
         new <T>();
@@ -72,8 +68,6 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
     var someGenerics3: someGenerics3;
     new someGenerics3(() => '');
     new someGenerics3<Window>(() => undefined);
-                      ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     new someGenerics3<number>(() => 3);
     
     // 2 parameter generic call with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
@@ -155,18 +149,12 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
     interface A92 {
         x: number;
         z?: Window;
-            ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     }
     var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
-                                                      ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     var a9e: {};
         ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts 119:4, but here has type '{}'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts 119:4, but here has type '{}'.
     var a9f = new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
-                                                           ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
                                                                              ~~~~~
 !!! error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
 !!! error TS2345:   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
diff --git a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.symbols b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.symbols
index f251fb62753..6acbb6225a5 100644
--- a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.symbols
@@ -151,6 +151,7 @@ new someGenerics3(() => '');
 
 new someGenerics3<Window>(() => undefined);
 >someGenerics3 : Symbol(someGenerics3, Decl(typeArgumentInferenceConstructSignatures.ts, 42, 62), Decl(typeArgumentInferenceConstructSignatures.ts, 48, 3))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 new someGenerics3<number>(() => 3);
@@ -405,6 +406,7 @@ interface A92 {
 
     z?: Window;
 >z : Symbol(A92.z, Decl(typeArgumentInferenceConstructSignatures.ts, 116, 14))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >a9e : Symbol(a9e, Decl(typeArgumentInferenceConstructSignatures.ts, 119, 3), Decl(typeArgumentInferenceConstructSignatures.ts, 120, 3))
@@ -412,6 +414,7 @@ var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(typeArgumentInferenceConstructSignatures.ts, 119, 40))
 >z : Symbol(z, Decl(typeArgumentInferenceConstructSignatures.ts, 119, 46))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeArgumentInferenceConstructSignatures.ts, 119, 61))
 >y : Symbol(y, Decl(typeArgumentInferenceConstructSignatures.ts, 119, 67))
 
@@ -425,6 +428,7 @@ var a9f = new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' }
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(typeArgumentInferenceConstructSignatures.ts, 121, 45))
 >z : Symbol(z, Decl(typeArgumentInferenceConstructSignatures.ts, 121, 51))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeArgumentInferenceConstructSignatures.ts, 121, 66))
 >y : Symbol(y, Decl(typeArgumentInferenceConstructSignatures.ts, 121, 72))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types
index 04dae1dafa7..125bd236b37 100644
--- a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types
+++ b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types
@@ -189,7 +189,7 @@ new someGenerics3(() => '');
 new someGenerics3<Window>(() => undefined);
 >new someGenerics3<Window>(() => undefined) : any
 >someGenerics3 : someGenerics3
->Window : No type information available!
+>Window : Window
 >() => undefined : () => any
 >undefined : undefined
 
@@ -520,19 +520,19 @@ interface A92 {
 >x : number
 
     z?: Window;
->z : any
->Window : No type information available!
+>z : Window
+>Window : Window
 }
 var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
->a9e : { x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }
->new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' }) : { x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }
+>a9e : { x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }
+>new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' }) : { x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }
 >someGenerics9 : someGenerics9
 >undefined : undefined
->{ x: 6, z: window } : { x: number; z: any; }
+>{ x: 6, z: window } : { x: number; z: Window; }
 >x : number
 >6 : 6
->z : any
->window : any
+>z : Window
+>window : Window
 >{ x: 6, y: '' } : { x: number; y: string; }
 >x : number
 >6 : 6
@@ -540,7 +540,7 @@ var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >'' : ""
 
 var a9e: {};
->a9e : { x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }
+>a9e : { x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }
 
 var a9f = new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >a9f : any
@@ -548,11 +548,11 @@ var a9f = new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' }
 >someGenerics9 : someGenerics9
 >A92 : A92
 >undefined : undefined
->{ x: 6, z: window } : { x: number; z: any; }
+>{ x: 6, z: window } : { x: number; z: Window; }
 >x : number
 >6 : 6
->z : any
->window : any
+>z : Window
+>window : Window
 >{ x: 6, y: '' } : { x: number; y: string; }
 >x : number
 >6 : 6
diff --git a/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.symbols b/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.symbols
index 79ab6f0e276..f98237f556d 100644
--- a/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.symbols
@@ -2,7 +2,7 @@
 function fn<A extends Date, B extends A, C extends B>(a: A, b: B, c: C) {
 >fn : Symbol(fn, Decl(typeArgumentInferenceTransitiveConstraints.ts, 0, 0))
 >A : Symbol(A, Decl(typeArgumentInferenceTransitiveConstraints.ts, 0, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(typeArgumentInferenceTransitiveConstraints.ts, 0, 27))
 >A : Symbol(A, Decl(typeArgumentInferenceTransitiveConstraints.ts, 0, 12))
 >C : Symbol(C, Decl(typeArgumentInferenceTransitiveConstraints.ts, 0, 40))
@@ -23,11 +23,11 @@ function fn<A extends Date, B extends A, C extends B>(a: A, b: B, c: C) {
 var d = fn(new Date(), new Date(), new Date());
 >d : Symbol(d, Decl(typeArgumentInferenceTransitiveConstraints.ts, 4, 3), Decl(typeArgumentInferenceTransitiveConstraints.ts, 5, 3))
 >fn : Symbol(fn, Decl(typeArgumentInferenceTransitiveConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var d: Date[]; // Should be OK (d should be Date[])
 >d : Symbol(d, Decl(typeArgumentInferenceTransitiveConstraints.ts, 4, 3), Decl(typeArgumentInferenceTransitiveConstraints.ts, 5, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt b/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
index 2b305390689..3713e8dd983 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
@@ -1,8 +1,9 @@
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(11,17): error TS2344: Type '{}' does not satisfy the constraint 'number'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(16,23): error TS2344: Type 'number' does not satisfy the constraint 'string'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(17,23): error TS2344: Type '{}' does not satisfy the constraint 'number'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(32,34): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(34,15): error TS2304: Cannot find name 'Window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(33,15): error TS2345: Argument of type '() => string' is not assignable to parameter of type '() => Window'.
+  Type 'string' is not assignable to type 'Window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(35,15): error TS2344: Type 'number' does not satisfy the constraint 'Window'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(41,35): error TS2345: Argument of type '(x: string) => string' is not assignable to parameter of type '(x: number) => void'.
   Types of parameters 'x' and 'x' are incompatible.
     Type 'number' is not assignable to type 'string'.
@@ -15,15 +16,12 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
     Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(66,31): error TS2345: Argument of type '<A, B extends string, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void' is not assignable to parameter of type 'string'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(73,29): error TS2345: Argument of type '0' is not assignable to parameter of type '""'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(85,9): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,47): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(88,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts 86:4, but here has type '{}'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(89,52): error TS2304: Cannot find name 'window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(88,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts 86:4, but here has type '{}'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(89,70): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
 
 
-==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts (16 errors) ====
+==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts (13 errors) ====
     // Generic call with no parameters
     function noParams<T extends {}>() { }
     noParams();
@@ -62,13 +60,14 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
     
     // Generic call with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
     function someGenerics3<T extends Window>(producer: () => T) { }
-                                     ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     someGenerics3(() => ''); // Error
+                  ~~~~~~~~
+!!! error TS2345: Argument of type '() => string' is not assignable to parameter of type '() => Window'.
+!!! error TS2345:   Type 'string' is not assignable to type 'Window'.
     someGenerics3<Window>(() => undefined);
-                  ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     someGenerics3<number>(() => 3); // Error
+                  ~~~~~~
+!!! error TS2344: Type 'number' does not satisfy the constraint 'Window'.
     
     // 2 parameter generic call with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
     function someGenerics4<T, U extends number>(n: T, f: (x: U) => void) { }
@@ -137,18 +136,12 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
     interface A92 {
         x: number;
         z?: Window;
-            ~~~~~~
-!!! error TS2304: Cannot find name 'Window'.
     }
     var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
-                                                  ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     var a9e: {};
         ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts 86:4, but here has type '{}'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'a9e' has type '{ x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }' at tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts 86:4, but here has type '{}'.
     var a9f = someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
-                                                       ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
                                                                          ~~~~~
 !!! error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
 !!! error TS2345:   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraints.symbols b/tests/baselines/reference/typeArgumentInferenceWithConstraints.symbols
index 435dfe41e10..52789f14706 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithConstraints.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithConstraints.symbols
@@ -111,6 +111,7 @@ someGenerics2b<string, number>((n, t) => n.substr(t * t));
 function someGenerics3<T extends Window>(producer: () => T) { }
 >someGenerics3 : Symbol(someGenerics3, Decl(typeArgumentInferenceWithConstraints.ts, 28, 58))
 >T : Symbol(T, Decl(typeArgumentInferenceWithConstraints.ts, 31, 23))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >producer : Symbol(producer, Decl(typeArgumentInferenceWithConstraints.ts, 31, 41))
 >T : Symbol(T, Decl(typeArgumentInferenceWithConstraints.ts, 31, 23))
 
@@ -119,6 +120,7 @@ someGenerics3(() => ''); // Error
 
 someGenerics3<Window>(() => undefined);
 >someGenerics3 : Symbol(someGenerics3, Decl(typeArgumentInferenceWithConstraints.ts, 28, 58))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 someGenerics3<number>(() => 3); // Error
@@ -340,6 +342,7 @@ interface A92 {
 
     z?: Window;
 >z : Symbol(A92.z, Decl(typeArgumentInferenceWithConstraints.ts, 83, 14))
+>Window : Symbol(Window, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >a9e : Symbol(a9e, Decl(typeArgumentInferenceWithConstraints.ts, 86, 3), Decl(typeArgumentInferenceWithConstraints.ts, 87, 3))
@@ -347,6 +350,7 @@ var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(typeArgumentInferenceWithConstraints.ts, 86, 36))
 >z : Symbol(z, Decl(typeArgumentInferenceWithConstraints.ts, 86, 42))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeArgumentInferenceWithConstraints.ts, 86, 57))
 >y : Symbol(y, Decl(typeArgumentInferenceWithConstraints.ts, 86, 63))
 
@@ -360,6 +364,7 @@ var a9f = someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(typeArgumentInferenceWithConstraints.ts, 88, 41))
 >z : Symbol(z, Decl(typeArgumentInferenceWithConstraints.ts, 88, 47))
+>window : Symbol(window, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeArgumentInferenceWithConstraints.ts, 88, 62))
 >y : Symbol(y, Decl(typeArgumentInferenceWithConstraints.ts, 88, 68))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraints.types b/tests/baselines/reference/typeArgumentInferenceWithConstraints.types
index 4ca65f02b02..45510dd9f8d 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithConstraints.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithConstraints.types
@@ -146,28 +146,28 @@ someGenerics2b<string, number>((n, t) => n.substr(t * t));
 
 // Generic call with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
 function someGenerics3<T extends Window>(producer: () => T) { }
->someGenerics3 : <T extends any>(producer: () => T) => void
+>someGenerics3 : <T extends Window>(producer: () => T) => void
 >T : T
->Window : No type information available!
+>Window : Window
 >producer : () => T
 >T : T
 
 someGenerics3(() => ''); // Error
->someGenerics3(() => '') : void
->someGenerics3 : <T extends any>(producer: () => T) => void
+>someGenerics3(() => '') : any
+>someGenerics3 : <T extends Window>(producer: () => T) => void
 >() => '' : () => string
 >'' : ""
 
 someGenerics3<Window>(() => undefined);
 >someGenerics3<Window>(() => undefined) : void
->someGenerics3 : <T extends any>(producer: () => T) => void
->Window : No type information available!
+>someGenerics3 : <T extends Window>(producer: () => T) => void
+>Window : Window
 >() => undefined : () => any
 >undefined : undefined
 
 someGenerics3<number>(() => 3); // Error
->someGenerics3<number>(() => 3) : void
->someGenerics3 : <T extends any>(producer: () => T) => void
+>someGenerics3<number>(() => 3) : any
+>someGenerics3 : <T extends Window>(producer: () => T) => void
 >() => 3 : () => number
 >3 : 3
 
@@ -460,19 +460,19 @@ interface A92 {
 >x : number
 
     z?: Window;
->z : any
->Window : No type information available!
+>z : Window
+>Window : Window
 }
 var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
->a9e : { x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }
->someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' }) : { x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }
+>a9e : { x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }
+>someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' }) : { x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }
 >someGenerics9 : <T extends any>(a: T, b: T, c: T) => T
 >undefined : undefined
->{ x: 6, z: window } : { x: number; z: any; }
+>{ x: 6, z: window } : { x: number; z: Window; }
 >x : number
 >6 : 6
->z : any
->window : any
+>z : Window
+>window : Window
 >{ x: 6, y: '' } : { x: number; y: string; }
 >x : number
 >6 : 6
@@ -480,7 +480,7 @@ var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >'' : ""
 
 var a9e: {};
->a9e : { x: number; z: any; y?: undefined; } | { x: number; y: string; z?: undefined; }
+>a9e : { x: number; z: Window; y?: undefined; } | { x: number; y: string; z?: undefined; }
 
 var a9f = someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >a9f : any
@@ -488,11 +488,11 @@ var a9f = someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
 >someGenerics9 : <T extends any>(a: T, b: T, c: T) => T
 >A92 : A92
 >undefined : undefined
->{ x: 6, z: window } : { x: number; z: any; }
+>{ x: 6, z: window } : { x: number; z: Window; }
 >x : number
 >6 : 6
->z : any
->window : any
+>z : Window
+>window : Window
 >{ x: 6, y: '' } : { x: number; y: string; }
 >x : number
 >6 : 6
diff --git a/tests/baselines/reference/typeGuardsNestedAssignments.js b/tests/baselines/reference/typeGuardsNestedAssignments.js
index 55778a49941..fad61ebec35 100644
--- a/tests/baselines/reference/typeGuardsNestedAssignments.js
+++ b/tests/baselines/reference/typeGuardsNestedAssignments.js
@@ -81,5 +81,5 @@ function f4() {
 var re = /./g;
 var match;
 while ((match = re.exec("xxx")) != null) {
-    var length = match[1].length + match[2].length;
+    var length_1 = match[1].length + match[2].length;
 }
diff --git a/tests/baselines/reference/typeInferenceLiteralUnion.symbols b/tests/baselines/reference/typeInferenceLiteralUnion.symbols
index 51fc4c828ec..011dea66f24 100644
--- a/tests/baselines/reference/typeInferenceLiteralUnion.symbols
+++ b/tests/baselines/reference/typeInferenceLiteralUnion.symbols
@@ -5,7 +5,7 @@
  */
 export type Primitive = number | string | boolean | Date;
 >Primitive : Symbol(Primitive, Decl(typeInferenceLiteralUnion.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 /**
  * Administrivia: anything with a valueOf(): number method is comparable, so we allow it in numeric operations
diff --git a/tests/baselines/reference/typeOfThisInMemberFunctions.symbols b/tests/baselines/reference/typeOfThisInMemberFunctions.symbols
index a98234023c5..c2c90ef3434 100644
--- a/tests/baselines/reference/typeOfThisInMemberFunctions.symbols
+++ b/tests/baselines/reference/typeOfThisInMemberFunctions.symbols
@@ -47,7 +47,7 @@ class D<T> {
 class E<T extends Date> {
 >E : Symbol(E, Decl(typeOfThisInMemberFunctions.ts, 19, 1))
 >T : Symbol(T, Decl(typeOfThisInMemberFunctions.ts, 21, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     x: T;
 >x : Symbol(E.x, Decl(typeOfThisInMemberFunctions.ts, 21, 25))
diff --git a/tests/baselines/reference/typeParameterAssignability2.symbols b/tests/baselines/reference/typeParameterAssignability2.symbols
index 6650db938f0..0bf94533dde 100644
--- a/tests/baselines/reference/typeParameterAssignability2.symbols
+++ b/tests/baselines/reference/typeParameterAssignability2.symbols
@@ -85,7 +85,7 @@ function foo4<T extends U, U extends V, V extends Date>(t: T, u: U, v: V) {
 >U : Symbol(U, Decl(typeParameterAssignability2.ts, 23, 26))
 >V : Symbol(V, Decl(typeParameterAssignability2.ts, 23, 39))
 >V : Symbol(V, Decl(typeParameterAssignability2.ts, 23, 39))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >t : Symbol(t, Decl(typeParameterAssignability2.ts, 23, 56))
 >T : Symbol(T, Decl(typeParameterAssignability2.ts, 23, 14))
 >u : Symbol(u, Decl(typeParameterAssignability2.ts, 23, 61))
@@ -103,7 +103,7 @@ function foo4<T extends U, U extends V, V extends Date>(t: T, u: U, v: V) {
 
     t = new Date(); // error
 >t : Symbol(t, Decl(typeParameterAssignability2.ts, 23, 56))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     u = t;
 >u : Symbol(u, Decl(typeParameterAssignability2.ts, 23, 61))
@@ -115,7 +115,7 @@ function foo4<T extends U, U extends V, V extends Date>(t: T, u: U, v: V) {
 
     u = new Date(); // error
 >u : Symbol(u, Decl(typeParameterAssignability2.ts, 23, 61))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     v = t;
 >v : Symbol(v, Decl(typeParameterAssignability2.ts, 23, 67))
@@ -127,11 +127,11 @@ function foo4<T extends U, U extends V, V extends Date>(t: T, u: U, v: V) {
 
     v = new Date(); // ok
 >v : Symbol(v, Decl(typeParameterAssignability2.ts, 23, 67))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     var d: Date;
 >d : Symbol(d, Decl(typeParameterAssignability2.ts, 36, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d = t; // ok
 >d : Symbol(d, Decl(typeParameterAssignability2.ts, 36, 7))
@@ -150,7 +150,7 @@ function foo4<T extends U, U extends V, V extends Date>(t: T, u: U, v: V) {
 function foo5<V extends Date, U extends V, T extends U>(t: T, u: U, v: V) {
 >foo5 : Symbol(foo5, Decl(typeParameterAssignability2.ts, 40, 1))
 >V : Symbol(V, Decl(typeParameterAssignability2.ts, 43, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParameterAssignability2.ts, 43, 29))
 >V : Symbol(V, Decl(typeParameterAssignability2.ts, 43, 14))
 >T : Symbol(T, Decl(typeParameterAssignability2.ts, 43, 42))
@@ -172,7 +172,7 @@ function foo5<V extends Date, U extends V, T extends U>(t: T, u: U, v: V) {
 
     t = new Date(); // error
 >t : Symbol(t, Decl(typeParameterAssignability2.ts, 43, 56))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     u = t;
 >u : Symbol(u, Decl(typeParameterAssignability2.ts, 43, 61))
@@ -184,7 +184,7 @@ function foo5<V extends Date, U extends V, T extends U>(t: T, u: U, v: V) {
 
     u = new Date(); // error
 >u : Symbol(u, Decl(typeParameterAssignability2.ts, 43, 61))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     v = t;
 >v : Symbol(v, Decl(typeParameterAssignability2.ts, 43, 67))
@@ -196,11 +196,11 @@ function foo5<V extends Date, U extends V, T extends U>(t: T, u: U, v: V) {
 
     v = new Date(); // ok
 >v : Symbol(v, Decl(typeParameterAssignability2.ts, 43, 67))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     var d: Date;
 >d : Symbol(d, Decl(typeParameterAssignability2.ts, 56, 7))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d = t; // ok
 >d : Symbol(d, Decl(typeParameterAssignability2.ts, 56, 7))
diff --git a/tests/baselines/reference/typeParameterConstraints1.symbols b/tests/baselines/reference/typeParameterConstraints1.symbols
index 32595208b8a..5d724139442 100644
--- a/tests/baselines/reference/typeParameterConstraints1.symbols
+++ b/tests/baselines/reference/typeParameterConstraints1.symbols
@@ -20,7 +20,7 @@ function foo3<T extends string>(test: T) { }
 function foo4<T extends Date>(test: T) { } // valid
 >foo4 : Symbol(foo4, Decl(typeParameterConstraints1.ts, 2, 44))
 >T : Symbol(T, Decl(typeParameterConstraints1.ts, 3, 14))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >test : Symbol(test, Decl(typeParameterConstraints1.ts, 3, 30))
 >T : Symbol(T, Decl(typeParameterConstraints1.ts, 3, 14))
 
diff --git a/tests/baselines/reference/typeParameterUsedAsConstraint.symbols b/tests/baselines/reference/typeParameterUsedAsConstraint.symbols
index 2ab34915a65..17a1d454e50 100644
--- a/tests/baselines/reference/typeParameterUsedAsConstraint.symbols
+++ b/tests/baselines/reference/typeParameterUsedAsConstraint.symbols
@@ -14,7 +14,7 @@ class C2<T extends U, U> { }
 class C3<T extends Date, U extends T> { }
 >C3 : Symbol(C3, Decl(typeParameterUsedAsConstraint.ts, 1, 28))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 2, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 2, 24))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 2, 9))
 
@@ -23,7 +23,7 @@ class C4<T extends U, U extends Date> { }
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 3, 9))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 3, 21))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 3, 21))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C5<T extends U, U extends V, V> { }
 >C5 : Symbol(C5, Decl(typeParameterUsedAsConstraint.ts, 3, 41))
@@ -56,7 +56,7 @@ interface I2<T extends U, U> { }
 interface I3<T extends Date, U extends T> { }
 >I3 : Symbol(I3, Decl(typeParameterUsedAsConstraint.ts, 8, 32))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 9, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 9, 28))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 9, 13))
 
@@ -65,7 +65,7 @@ interface I4<T extends U, U extends Date> { }
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 10, 13))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 10, 25))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 10, 25))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 interface I5<T extends U, U extends V, V> { }
 >I5 : Symbol(I5, Decl(typeParameterUsedAsConstraint.ts, 10, 45))
@@ -98,7 +98,7 @@ function f2<T extends U, U>() { }
 function f3<T extends Date, U extends T>() { }
 >f3 : Symbol(f3, Decl(typeParameterUsedAsConstraint.ts, 15, 33))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 16, 27))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 16, 12))
 
@@ -107,7 +107,7 @@ function f4<T extends U, U extends Date>() { }
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 17, 12))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 17, 24))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 17, 24))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function f5<T extends U, U extends V, V>() { }
 >f5 : Symbol(f5, Decl(typeParameterUsedAsConstraint.ts, 17, 46))
@@ -140,7 +140,7 @@ var e2 = <T extends U, U>() => { }
 var e3 = <T extends Date, U extends T>() => { }
 >e3 : Symbol(e3, Decl(typeParameterUsedAsConstraint.ts, 23, 3))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 23, 10))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 23, 25))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 23, 10))
 
@@ -149,7 +149,7 @@ var e4 = <T extends U, U extends Date>() => { }
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 24, 10))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 24, 22))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 24, 22))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var e5 = <T extends U, U extends V, V>() => { }
 >e5 : Symbol(e5, Decl(typeParameterUsedAsConstraint.ts, 25, 3))
@@ -182,7 +182,7 @@ var a2: { <T extends U, U>(): void }
 var a3: { <T extends Date, U extends T>(): void }
 >a3 : Symbol(a3, Decl(typeParameterUsedAsConstraint.ts, 30, 3))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 30, 11))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 30, 26))
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 30, 11))
 
@@ -191,7 +191,7 @@ var a4: { <T extends U, U extends Date>(): void }
 >T : Symbol(T, Decl(typeParameterUsedAsConstraint.ts, 31, 11))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 31, 23))
 >U : Symbol(U, Decl(typeParameterUsedAsConstraint.ts, 31, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var a5: { <T extends U, U extends V, V>(): void }
 >a5 : Symbol(a5, Decl(typeParameterUsedAsConstraint.ts, 32, 3))
diff --git a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols
index 39479bdba90..23eb6ed8c5f 100644
--- a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols
+++ b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols
@@ -144,21 +144,21 @@ class C<T> {
     foo4<T extends Date>(x: T);
 >foo4 : Symbol(C.foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 9))
 
     foo4<T extends Date>(x: T); // no error, different declaration for each T
 >foo4 : Symbol(C.foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 9))
 
     foo4<T extends Date>(x: T) { }
 >foo4 : Symbol(C.foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 9))
 }
@@ -166,7 +166,7 @@ class C<T> {
 class C2<T extends Date> {
 >C2 : Symbol(C2, Decl(typeParametersAreIdenticalToThemselves.ts, 36, 1))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 38, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo1(x: T);
 >foo1 : Symbol(C2.foo1, Decl(typeParametersAreIdenticalToThemselves.ts, 38, 26), Decl(typeParametersAreIdenticalToThemselves.ts, 39, 15), Decl(typeParametersAreIdenticalToThemselves.ts, 40, 15))
@@ -271,14 +271,14 @@ interface I<T> {
     foo4<T extends Date>(x: T);
 >foo4 : Symbol(I.foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 60, 18), Decl(typeParametersAreIdenticalToThemselves.ts, 62, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 9))
 
     foo4<T extends Date>(x: T); // no error, different declaration for each T
 >foo4 : Symbol(I.foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 60, 18), Decl(typeParametersAreIdenticalToThemselves.ts, 62, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 9))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 9))
 }
@@ -286,7 +286,7 @@ interface I<T> {
 interface I2<T extends Date> {
 >I2 : Symbol(I2, Decl(typeParametersAreIdenticalToThemselves.ts, 64, 1))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 66, 13))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo1(x: T);
 >foo1 : Symbol(I2.foo1, Decl(typeParametersAreIdenticalToThemselves.ts, 66, 30), Decl(typeParametersAreIdenticalToThemselves.ts, 67, 15))
diff --git a/tests/baselines/reference/typeParametersShouldNotBeEqual2.symbols b/tests/baselines/reference/typeParametersShouldNotBeEqual2.symbols
index e281f709341..b87249e2a5d 100644
--- a/tests/baselines/reference/typeParametersShouldNotBeEqual2.symbols
+++ b/tests/baselines/reference/typeParametersShouldNotBeEqual2.symbols
@@ -2,9 +2,9 @@
 function ff<T extends Date, U extends Date, V>(x: T, y: U, z: V) {
 >ff : Symbol(ff, Decl(typeParametersShouldNotBeEqual2.ts, 0, 0))
 >T : Symbol(T, Decl(typeParametersShouldNotBeEqual2.ts, 0, 12))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(typeParametersShouldNotBeEqual2.ts, 0, 27))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >V : Symbol(V, Decl(typeParametersShouldNotBeEqual2.ts, 0, 43))
 >x : Symbol(x, Decl(typeParametersShouldNotBeEqual2.ts, 0, 47))
 >T : Symbol(T, Decl(typeParametersShouldNotBeEqual2.ts, 0, 12))
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index 1080fa39e89..7bc6cecf543 100644
--- a/tests/baselines/reference/typedArrays.symbols
+++ b/tests/baselines/reference/typedArrays.symbols
@@ -7,39 +7,39 @@ function CreateTypedArrayTypes() {
 
     typedArrays[0] = Int8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 1, 7))
@@ -54,47 +54,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 16, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 15, 45))
 
     return typedArrays;
@@ -110,47 +110,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 31, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 30, 44))
 
     return typedArrays;
@@ -166,65 +166,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     return typedArrays;
@@ -234,72 +234,72 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >CreateIntegerTypedArraysFromArrayLike : Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 58, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
->ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.es6.d.ts, --, --))
 
     var typedArrays = [];
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     return typedArrays;
@@ -315,65 +315,65 @@ function CreateTypedArraysOf(obj) {
 
     typedArrays[0] = Int8Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Int8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Int8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[1] = Uint8Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[2] = Int16Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Int16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Int16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[3] = Uint16Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[4] = Int32Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Int32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Int32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[5] = Uint32Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[6] = Float32Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Float32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Float32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[7] = Float64Array.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Float64ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Float64ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     typedArrays[8] = Uint8ClampedArray.of(...obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 76, 7))
->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 75, 29))
 
     return typedArrays;
@@ -388,57 +388,57 @@ function CreateTypedArraysOf2() {
 
     typedArrays[0] = Int8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Int8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Int8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[1] = Uint8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[2] = Int16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Int16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Int16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[3] = Uint16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[4] = Int32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Int32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Int32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[5] = Uint32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[6] = Float32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Float32ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Float32ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[7] = Float64Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Float64ArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Float64ArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es5.d.ts, --, --))
+>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.es6.d.ts, --, --))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 91, 7))
@@ -447,7 +447,7 @@ function CreateTypedArraysOf2() {
 function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:number)=> number) {
 >CreateTypedArraysFromMapFn : Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 103, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
->ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.es6.d.ts, --, --))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 >n : Symbol(n, Decl(typedArrays.ts, 105, 67))
 >v : Symbol(v, Decl(typedArrays.ts, 105, 76))
@@ -457,73 +457,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
@@ -534,7 +534,7 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v:number)=> number, thisArg: {}) {
 >CreateTypedArraysFromThisObj : Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 118, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
->ArrayLike : Symbol(ArrayLike, Decl(lib.es5.d.ts, --, --))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.es6.d.ts, --, --))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >n : Symbol(n, Decl(typedArrays.ts, 120, 69))
 >v : Symbol(v, Decl(typedArrays.ts, 120, 78))
@@ -545,81 +545,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
diff --git a/tests/baselines/reference/typedArraysCrossAssignability01.symbols b/tests/baselines/reference/typedArraysCrossAssignability01.symbols
index f3d2a882811..be3070df6ef 100644
--- a/tests/baselines/reference/typedArraysCrossAssignability01.symbols
+++ b/tests/baselines/reference/typedArraysCrossAssignability01.symbols
@@ -4,39 +4,39 @@ function CheckAssignability() {
 
     let arr_Int8Array           = new Int8Array(1);
 >arr_Int8Array : Symbol(arr_Int8Array, Decl(typedArraysCrossAssignability01.ts, 1, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Uint8Array          = new Uint8Array(1);
 >arr_Uint8Array : Symbol(arr_Uint8Array, Decl(typedArraysCrossAssignability01.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Int16Array          = new Int16Array(1);
 >arr_Int16Array : Symbol(arr_Int16Array, Decl(typedArraysCrossAssignability01.ts, 3, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Uint16Array         = new Uint16Array(1);
 >arr_Uint16Array : Symbol(arr_Uint16Array, Decl(typedArraysCrossAssignability01.ts, 4, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Int32Array          = new Int32Array(1);
 >arr_Int32Array : Symbol(arr_Int32Array, Decl(typedArraysCrossAssignability01.ts, 5, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Uint32Array         = new Uint32Array(1);
 >arr_Uint32Array : Symbol(arr_Uint32Array, Decl(typedArraysCrossAssignability01.ts, 6, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Float32Array        = new Float32Array(1);
 >arr_Float32Array : Symbol(arr_Float32Array, Decl(typedArraysCrossAssignability01.ts, 7, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Float64Array        = new Float64Array(1);
 >arr_Float64Array : Symbol(arr_Float64Array, Decl(typedArraysCrossAssignability01.ts, 8, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     let arr_Uint8ClampedArray   = new Uint8ClampedArray(1);
 >arr_Uint8ClampedArray : Symbol(arr_Uint8ClampedArray, Decl(typedArraysCrossAssignability01.ts, 9, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 
     arr_Int8Array = arr_Int8Array;
 >arr_Int8Array : Symbol(arr_Int8Array, Decl(typedArraysCrossAssignability01.ts, 1, 7))
diff --git a/tests/baselines/reference/undefinedAssignableToEveryType.symbols b/tests/baselines/reference/undefinedAssignableToEveryType.symbols
index c48839ea50f..18f568da52e 100644
--- a/tests/baselines/reference/undefinedAssignableToEveryType.symbols
+++ b/tests/baselines/reference/undefinedAssignableToEveryType.symbols
@@ -41,7 +41,7 @@ var d: boolean = undefined;
 
 var e: Date = undefined;
 >e : Symbol(e, Decl(undefinedAssignableToEveryType.ts, 15, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var f: any = undefined;
@@ -119,7 +119,7 @@ function foo<T, U, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(undefinedAssignableToEveryType.ts, 32, 13))
 >U : Symbol(U, Decl(undefinedAssignableToEveryType.ts, 32, 15))
 >V : Symbol(V, Decl(undefinedAssignableToEveryType.ts, 32, 18))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(undefinedAssignableToEveryType.ts, 32, 35))
 >T : Symbol(T, Decl(undefinedAssignableToEveryType.ts, 32, 13))
 >y : Symbol(y, Decl(undefinedAssignableToEveryType.ts, 32, 40))
diff --git a/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols b/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols
index f2776039d3a..0d0c6917dc2 100644
--- a/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols
+++ b/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols
@@ -95,7 +95,7 @@ class D5 extends Base {
 
     foo: Date;
 >foo : Symbol(D5.foo, Decl(undefinedIsSubtypeOfEverything.ts, 45, 23))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols
index 41b0c811027..e9b267124b0 100644
--- a/tests/baselines/reference/underscoreTest1.symbols
+++ b/tests/baselines/reference/underscoreTest1.symbols
@@ -5,7 +5,7 @@ declare var $;
 >$ : Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
 
 declare function alert(x: string): void;
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 >x : Symbol(x, Decl(underscoreTest1_underscoreTests.ts, 3, 23))
 
 _.each([1, 2, 3], (num) => alert(num.toString()));
@@ -13,7 +13,7 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 >num.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
@@ -27,7 +27,7 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 6, 24))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
 >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 6, 52))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 >value.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
@@ -394,11 +394,11 @@ var buttonView = {
 
     onClick: function () { alert('clicked: ' + this.label); },
 >onClick : Symbol(onClick, Decl(underscoreTest1_underscoreTests.ts, 97, 24))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
     onHover: function () { alert('hovering: ' + this.label); }
 >onHover : Symbol(onHover, Decl(underscoreTest1_underscoreTests.ts, 98, 62))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 };
 _.bindAll(buttonView);
@@ -437,7 +437,7 @@ var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
 >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58))
 >message : Symbol(message, Decl(underscoreTest1_underscoreTests.ts, 108, 18))
 >rest : Symbol(rest, Decl(underscoreTest1_underscoreTests.ts, 108, 35))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 _.delay(log, 1000, 'logged later');
 >_.delay : Symbol(Underscore.Static.delay, Decl(underscoreTest1_underscore.ts, 557, 73))
@@ -449,11 +449,11 @@ _.defer(function () { alert('deferred'); });
 >_.defer : Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 559, 68))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >defer : Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 559, 68))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var updatePosition = () => alert('updating position...');
 >updatePosition : Symbol(updatePosition, Decl(underscoreTest1_underscoreTests.ts, 113, 3))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var throttled = _.throttle(updatePosition, 100);
 >throttled : Symbol(throttled, Decl(underscoreTest1_underscoreTests.ts, 114, 3))
@@ -468,7 +468,7 @@ $(null).scroll(throttled);
 
 var calculateLayout = () => alert('calculating layout...');
 >calculateLayout : Symbol(calculateLayout, Decl(underscoreTest1_underscoreTests.ts, 117, 3))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var lazyLayout = _.debounce(calculateLayout, 300);
 >lazyLayout : Symbol(lazyLayout, Decl(underscoreTest1_underscoreTests.ts, 118, 3))
@@ -483,7 +483,7 @@ $(null).resize(lazyLayout);
 
 var createApplication = () => alert('creating application...');
 >createApplication : Symbol(createApplication, Decl(underscoreTest1_underscoreTests.ts, 121, 3))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var initialize = _.once(createApplication);
 >initialize : Symbol(initialize, Decl(underscoreTest1_underscoreTests.ts, 122, 3))
@@ -503,7 +503,7 @@ var notes: any[];
 
 var render = () => alert("rendering...");
 >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var renderNotes = _.after(notes.length, render);
 >renderNotes : Symbol(renderNotes, Decl(underscoreTest1_underscoreTests.ts, 128, 3))
@@ -662,7 +662,7 @@ _.chain([1, 2, 3, 200])
 
     .tap(<any>alert)
 >tap : Symbol(Underscore.ChainedArray.tap, Decl(underscoreTest1_underscore.ts, 325, 33))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
     .map(function (num) { return num * num })
 >map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 82))
@@ -750,7 +750,7 @@ _.isFunction(alert);
 >_.isFunction : Symbol(Underscore.Static.isFunction, Decl(underscoreTest1_underscore.ts, 606, 42))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >isFunction : Symbol(Underscore.Static.isFunction, Decl(underscoreTest1_underscore.ts, 606, 42))
->alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --), Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 _.isString("moe");
 >_.isString : Symbol(Underscore.Static.isString, Decl(underscoreTest1_underscore.ts, 607, 41))
@@ -782,7 +782,7 @@ _.isDate(new Date());
 >_.isDate : Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 611, 40))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >isDate : Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 611, 40))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 _.isRegExp(/moe/);
 >_.isRegExp : Symbol(Underscore.Static.isRegExp, Decl(underscoreTest1_underscore.ts, 612, 37))
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 4ab097e3316..b528f45d484 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -5,7 +5,7 @@ declare var $;
 >$ : any
 
 declare function alert(x: string): void;
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >x : string
 
 _.each([1, 2, 3], (num) => alert(num.toString()));
@@ -20,7 +20,7 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 >(num) => alert(num.toString()) : (num: number) => void
 >num : number
 >alert(num.toString()) : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >num.toString() : string
 >num.toString : (radix?: number) => string
 >num : number
@@ -42,7 +42,7 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 >value : number
 >key : string
 >alert(value.toString()) : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >value.toString() : string
 >value.toString : (radix?: number) => string
 >value : number
@@ -824,7 +824,7 @@ var buttonView = {
 >onClick : () => void
 >function () { alert('clicked: ' + this.label); } : () => void
 >alert('clicked: ' + this.label) : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >'clicked: ' + this.label : string
 >'clicked: ' : "clicked: "
 >this.label : any
@@ -835,7 +835,7 @@ var buttonView = {
 >onHover : () => void
 >function () { alert('hovering: ' + this.label); } : () => void
 >alert('hovering: ' + this.label) : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >'hovering: ' + this.label : string
 >'hovering: ' : "hovering: "
 >this.label : any
@@ -918,14 +918,14 @@ _.defer(function () { alert('deferred'); });
 >defer : (func: Function, ...args: any[]) => number
 >function () { alert('deferred'); } : () => void
 >alert('deferred') : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >'deferred' : "deferred"
 
 var updatePosition = () => alert('updating position...');
 >updatePosition : () => void
 >() => alert('updating position...') : () => void
 >alert('updating position...') : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >'updating position...' : "updating position..."
 
 var throttled = _.throttle(updatePosition, 100);
@@ -950,7 +950,7 @@ var calculateLayout = () => alert('calculating layout...');
 >calculateLayout : () => void
 >() => alert('calculating layout...') : () => void
 >alert('calculating layout...') : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >'calculating layout...' : "calculating layout..."
 
 var lazyLayout = _.debounce(calculateLayout, 300);
@@ -975,7 +975,7 @@ var createApplication = () => alert('creating application...');
 >createApplication : () => void
 >() => alert('creating application...') : () => void
 >alert('creating application...') : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >'creating application...' : "creating application..."
 
 var initialize = _.once(createApplication);
@@ -1001,7 +1001,7 @@ var render = () => alert("rendering...");
 >render : () => void
 >() => alert("rendering...") : () => void
 >alert("rendering...") : void
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 >"rendering..." : "rendering..."
 
 var renderNotes = _.after(notes.length, render);
@@ -1254,7 +1254,7 @@ _.chain([1, 2, 3, 200])
     .tap(<any>alert)
 >tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray<number>
 ><any>alert : any
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 
     .map(function (num) { return num * num })
 >map : <U>(iterator: Iterator_<number, U>, context?: any) => Underscore.ChainedArray<U>
@@ -1395,7 +1395,7 @@ _.isFunction(alert);
 >_.isFunction : (object: any) => boolean
 >_ : Underscore.Static
 >isFunction : (object: any) => boolean
->alert : (x: string) => void
+>alert : { (message?: any): void; (x: string): void; }
 
 _.isString("moe");
 >_.isString("moe") : boolean
diff --git a/tests/baselines/reference/unicodeIdentifierName2.errors.txt b/tests/baselines/reference/unicodeIdentifierName2.errors.txt
index 2eabbee8db1..d59b5c2b21a 100644
--- a/tests/baselines/reference/unicodeIdentifierName2.errors.txt
+++ b/tests/baselines/reference/unicodeIdentifierName2.errors.txt
@@ -1,11 +1,10 @@
 tests/cases/compiler/unicodeIdentifierName2.ts(1,6): error TS1127: Invalid character.
 tests/cases/compiler/unicodeIdentifierName2.ts(1,8): error TS1134: Variable declaration expected.
 tests/cases/compiler/unicodeIdentifierName2.ts(1,10): error TS1134: Variable declaration expected.
-tests/cases/compiler/unicodeIdentifierName2.ts(1,19): error TS2304: Cannot find name 'alert'.
 tests/cases/compiler/unicodeIdentifierName2.ts(1,26): error TS1127: Invalid character.
 
 
-==== tests/cases/compiler/unicodeIdentifierName2.ts (5 errors) ====
+==== tests/cases/compiler/unicodeIdentifierName2.ts (4 errors) ====
     var a₁ = "hello"; alert(a₁)
          
 !!! error TS1127: Invalid character.
@@ -13,7 +12,5 @@ tests/cases/compiler/unicodeIdentifierName2.ts(1,26): error TS1127: Invalid char
 !!! error TS1134: Variable declaration expected.
              ~~~~~~~
 !!! error TS1134: Variable declaration expected.
-                      ~~~~~
-!!! error TS2304: Cannot find name 'alert'.
                              
 !!! error TS1127: Invalid character.
\ No newline at end of file
diff --git a/tests/baselines/reference/unicodeIdentifierName2.symbols b/tests/baselines/reference/unicodeIdentifierName2.symbols
index a76866cc8af..c176395ca1c 100644
--- a/tests/baselines/reference/unicodeIdentifierName2.symbols
+++ b/tests/baselines/reference/unicodeIdentifierName2.symbols
@@ -1,5 +1,6 @@
 === tests/cases/compiler/unicodeIdentifierName2.ts ===
 var a₁ = "hello"; alert(a₁)
 >a : Symbol(a, Decl(unicodeIdentifierName2.ts, 0, 3))
+>alert : Symbol(alert, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(unicodeIdentifierName2.ts, 0, 3))
 
diff --git a/tests/baselines/reference/unicodeIdentifierName2.types b/tests/baselines/reference/unicodeIdentifierName2.types
index d6f0f1dbdcd..7e30ae54ed5 100644
--- a/tests/baselines/reference/unicodeIdentifierName2.types
+++ b/tests/baselines/reference/unicodeIdentifierName2.types
@@ -2,7 +2,7 @@
 var a₁ = "hello"; alert(a₁)
 >a : any
 >"hello" : "hello"
->alert(a₁) : any
->alert : any
+>alert(a₁) : void
+>alert : (message?: any) => void
 >a : any
 
diff --git a/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.symbols b/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.symbols
index 7bc6fd1f17c..d3905b6ee1e 100644
--- a/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.symbols
+++ b/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.symbols
@@ -73,7 +73,7 @@ interface I5 {
 
     [x: string]: Date;
 >x : Symbol(x, Decl(unionSubtypeIfEveryConstituentTypeIsSubtype.ts, 33, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: string | number;
 >foo : Symbol(I5.foo, Decl(unionSubtypeIfEveryConstituentTypeIsSubtype.ts, 33, 22))
diff --git a/tests/baselines/reference/unionTypeCallSignatures.symbols b/tests/baselines/reference/unionTypeCallSignatures.symbols
index 69f7b4d70c9..23a18efff22 100644
--- a/tests/baselines/reference/unionTypeCallSignatures.symbols
+++ b/tests/baselines/reference/unionTypeCallSignatures.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/union/unionTypeCallSignatures.ts ===
 var numOrDate: number | Date;
 >numOrDate : Symbol(numOrDate, Decl(unionTypeCallSignatures.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var strOrBoolean: string | boolean;
 >strOrBoolean : Symbol(strOrBoolean, Decl(unionTypeCallSignatures.ts, 1, 3))
@@ -15,7 +15,7 @@ var unionOfDifferentReturnType: { (a: number): number; } | { (a: number): Date;
 >unionOfDifferentReturnType : Symbol(unionOfDifferentReturnType, Decl(unionTypeCallSignatures.ts, 6, 3))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 6, 35))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 6, 62))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 numOrDate = unionOfDifferentReturnType(10);
 >numOrDate : Symbol(numOrDate, Decl(unionTypeCallSignatures.ts, 0, 3))
@@ -33,7 +33,7 @@ var unionOfDifferentReturnType1: { (a: number): number; (a: string): string; } |
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 11, 36))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 11, 57))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 11, 84))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 11, 103))
 
 numOrDate = unionOfDifferentReturnType1(10);
@@ -54,7 +54,7 @@ var unionOfDifferentParameterTypes: { (a: number): number; } | { (a: string): Da
 >unionOfDifferentParameterTypes : Symbol(unionOfDifferentParameterTypes, Decl(unionTypeCallSignatures.ts, 17, 3))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 17, 39))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 17, 66))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 unionOfDifferentParameterTypes(10);// error - no call signatures
 >unionOfDifferentParameterTypes : Symbol(unionOfDifferentParameterTypes, Decl(unionTypeCallSignatures.ts, 17, 3))
@@ -69,7 +69,7 @@ var unionOfDifferentNumberOfSignatures: { (a: number): number; } | { (a: number)
 >unionOfDifferentNumberOfSignatures : Symbol(unionOfDifferentNumberOfSignatures, Decl(unionTypeCallSignatures.ts, 22, 3))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 22, 43))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 22, 70))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(unionTypeCallSignatures.ts, 22, 89))
 
 unionOfDifferentNumberOfSignatures(); // error - no call signatures
diff --git a/tests/baselines/reference/unionTypeCallSignatures2.symbols b/tests/baselines/reference/unionTypeCallSignatures2.symbols
index 19279346cde..9193b90bab5 100644
--- a/tests/baselines/reference/unionTypeCallSignatures2.symbols
+++ b/tests/baselines/reference/unionTypeCallSignatures2.symbols
@@ -11,7 +11,7 @@ interface A {
 
     (x: Date): void;
 >x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 3, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     <T>(x: T[]): T[];
 >T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 4, 5))
@@ -31,7 +31,7 @@ interface B {
 
     (x: Date): void;
 >x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 10, 5))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     <T>(x: T[]): T[];
 >T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 11, 5))
diff --git a/tests/baselines/reference/unionTypeConstructSignatures.symbols b/tests/baselines/reference/unionTypeConstructSignatures.symbols
index d4291ecd326..cd8b873a543 100644
--- a/tests/baselines/reference/unionTypeConstructSignatures.symbols
+++ b/tests/baselines/reference/unionTypeConstructSignatures.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/union/unionTypeConstructSignatures.ts ===
 var numOrDate: number | Date;
 >numOrDate : Symbol(numOrDate, Decl(unionTypeConstructSignatures.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var strOrBoolean: string | boolean;
 >strOrBoolean : Symbol(strOrBoolean, Decl(unionTypeConstructSignatures.ts, 1, 3))
@@ -15,7 +15,7 @@ var unionOfDifferentReturnType: { new (a: number): number; } | { new (a: number)
 >unionOfDifferentReturnType : Symbol(unionOfDifferentReturnType, Decl(unionTypeConstructSignatures.ts, 6, 3))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 6, 39))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 6, 70))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 numOrDate = new unionOfDifferentReturnType(10);
 >numOrDate : Symbol(numOrDate, Decl(unionTypeConstructSignatures.ts, 0, 3))
@@ -33,7 +33,7 @@ var unionOfDifferentReturnType1: { new (a: number): number; new (a: string): str
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 11, 40))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 11, 65))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 11, 96))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 11, 119))
 
 numOrDate = new unionOfDifferentReturnType1(10);
@@ -54,7 +54,7 @@ var unionOfDifferentParameterTypes: { new (a: number): number; } | { new (a: str
 >unionOfDifferentParameterTypes : Symbol(unionOfDifferentParameterTypes, Decl(unionTypeConstructSignatures.ts, 17, 3))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 17, 43))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 17, 74))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 new unionOfDifferentParameterTypes(10);// error - no call signatures
 >unionOfDifferentParameterTypes : Symbol(unionOfDifferentParameterTypes, Decl(unionTypeConstructSignatures.ts, 17, 3))
@@ -69,7 +69,7 @@ var unionOfDifferentNumberOfSignatures: { new (a: number): number; } | { new (a:
 >unionOfDifferentNumberOfSignatures : Symbol(unionOfDifferentNumberOfSignatures, Decl(unionTypeConstructSignatures.ts, 22, 3))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 22, 47))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 22, 78))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(unionTypeConstructSignatures.ts, 22, 101))
 
 new unionOfDifferentNumberOfSignatures(); // error - no call signatures
diff --git a/tests/baselines/reference/unionTypeIndexSignature.symbols b/tests/baselines/reference/unionTypeIndexSignature.symbols
index dc3923f2f24..ba52a068476 100644
--- a/tests/baselines/reference/unionTypeIndexSignature.symbols
+++ b/tests/baselines/reference/unionTypeIndexSignature.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/union/unionTypeIndexSignature.ts ===
 var numOrDate: number | Date;
 >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anyVar: number;
 >anyVar : Symbol(anyVar, Decl(unionTypeIndexSignature.ts, 1, 3))
@@ -13,7 +13,7 @@ var unionOfDifferentReturnType: { [a: string]: number; } | { [a: string]: Date;
 >unionOfDifferentReturnType : Symbol(unionOfDifferentReturnType, Decl(unionTypeIndexSignature.ts, 6, 3))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 6, 35))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 6, 62))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 numOrDate = unionOfDifferentReturnType["hello"]; // number | Date
 >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3))
@@ -41,7 +41,7 @@ var unionOfDifferentReturnType1: { [a: number]: number; } | { [a: number]: Date;
 >unionOfDifferentReturnType1 : Symbol(unionOfDifferentReturnType1, Decl(unionTypeIndexSignature.ts, 16, 3))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 16, 36))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 16, 63))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 numOrDate = unionOfDifferentReturnType1["hello"]; // any
 >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3))
diff --git a/tests/baselines/reference/unknownSymbolOffContextualType1.symbols b/tests/baselines/reference/unknownSymbolOffContextualType1.symbols
index 3acf34ec9bf..8089af1d1fc 100644
--- a/tests/baselines/reference/unknownSymbolOffContextualType1.symbols
+++ b/tests/baselines/reference/unknownSymbolOffContextualType1.symbols
@@ -1,18 +1,18 @@
 === tests/cases/compiler/unknownSymbolOffContextualType1.ts ===
 declare var document: Document;
->document : Symbol(document, Decl(unknownSymbolOffContextualType1.ts, 0, 11))
->Document : Symbol(Document, Decl(unknownSymbolOffContextualType1.ts, 0, 31))
+>document : Symbol(document, Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 0, 11))
+>Document : Symbol(Document, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 0, 31))
 
 interface Document {
->Document : Symbol(Document, Decl(unknownSymbolOffContextualType1.ts, 0, 31))
+>Document : Symbol(Document, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 0, 31))
 
     getElementById(elementId: string): HTMLElement;
->getElementById : Symbol(Document.getElementById, Decl(unknownSymbolOffContextualType1.ts, 1, 20))
+>getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 1, 20))
 >elementId : Symbol(elementId, Decl(unknownSymbolOffContextualType1.ts, 2, 19))
->HTMLElement : Symbol(HTMLElement, Decl(unknownSymbolOffContextualType1.ts, 3, 1))
+>HTMLElement : Symbol(HTMLElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 3, 1))
 }
 interface HTMLElement {
->HTMLElement : Symbol(HTMLElement, Decl(unknownSymbolOffContextualType1.ts, 3, 1))
+>HTMLElement : Symbol(HTMLElement, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 3, 1))
 
     isDisabled: boolean;
 >isDisabled : Symbol(HTMLElement.isDisabled, Decl(unknownSymbolOffContextualType1.ts, 4, 23))
@@ -29,9 +29,9 @@ function getMaxWidth(elementNames: string[]) {
 >name : Symbol(name, Decl(unknownSymbolOffContextualType1.ts, 8, 46))
 
         return document.getElementById(name);
->document.getElementById : Symbol(Document.getElementById, Decl(unknownSymbolOffContextualType1.ts, 1, 20))
->document : Symbol(document, Decl(unknownSymbolOffContextualType1.ts, 0, 11))
->getElementById : Symbol(Document.getElementById, Decl(unknownSymbolOffContextualType1.ts, 1, 20))
+>document.getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 1, 20))
+>document : Symbol(document, Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 0, 11))
+>getElementById : Symbol(Document.getElementById, Decl(lib.d.ts, --, --), Decl(unknownSymbolOffContextualType1.ts, 1, 20))
 >name : Symbol(name, Decl(unknownSymbolOffContextualType1.ts, 8, 46))
 
     });
diff --git a/tests/baselines/reference/unknownSymbolOffContextualType1.types b/tests/baselines/reference/unknownSymbolOffContextualType1.types
index 7df3bd52cc9..211231823be 100644
--- a/tests/baselines/reference/unknownSymbolOffContextualType1.types
+++ b/tests/baselines/reference/unknownSymbolOffContextualType1.types
@@ -7,7 +7,7 @@ interface Document {
 >Document : Document
 
     getElementById(elementId: string): HTMLElement;
->getElementById : (elementId: string) => HTMLElement
+>getElementById : { (elementId: string): HTMLElement; (elementId: string): HTMLElement; }
 >elementId : string
 >HTMLElement : HTMLElement
 }
@@ -32,9 +32,9 @@ function getMaxWidth(elementNames: string[]) {
 
         return document.getElementById(name);
 >document.getElementById(name) : HTMLElement
->document.getElementById : (elementId: string) => HTMLElement
+>document.getElementById : { (elementId: string): HTMLElement; (elementId: string): HTMLElement; }
 >document : Document
->getElementById : (elementId: string) => HTMLElement
+>getElementById : { (elementId: string): HTMLElement; (elementId: string): HTMLElement; }
 >name : string
 
     });
diff --git a/tests/baselines/reference/useObjectValuesAndEntries3.symbols b/tests/baselines/reference/useObjectValuesAndEntries3.symbols
index 65d5175eaa6..1842e5eeb37 100644
--- a/tests/baselines/reference/useObjectValuesAndEntries3.symbols
+++ b/tests/baselines/reference/useObjectValuesAndEntries3.symbols
@@ -6,7 +6,7 @@ var o = { a: 1, b: 2 };
 
 for (var x of Object.values(o)) {
 >x : Symbol(x, Decl(useObjectValuesAndEntries3.ts, 2, 8))
->Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >o : Symbol(o, Decl(useObjectValuesAndEntries3.ts, 0, 3))
 
     let y = x;
@@ -16,6 +16,6 @@ for (var x of Object.values(o)) {
 
 var entries = Object.entries(o);
 >entries : Symbol(entries, Decl(useObjectValuesAndEntries3.ts, 6, 3))
->Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --), Decl(lib.es6.d.ts, --, --))
 >o : Symbol(o, Decl(useObjectValuesAndEntries3.ts, 0, 3))
 
diff --git a/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt b/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
index 46782aaa1d6..9143e4c81c8 100644
--- a/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
+++ b/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
@@ -1,6 +1,6 @@
-lib.d.ts(32,18): error TS2300: Duplicate identifier 'eval'.
 tests/cases/compiler/variableDeclarationInStrictMode1.ts(2,5): error TS1100: Invalid use of 'eval' in strict mode.
 tests/cases/compiler/variableDeclarationInStrictMode1.ts(2,5): error TS2300: Duplicate identifier 'eval'.
+lib.d.ts(32,18): error TS2300: Duplicate identifier 'eval'.
 
 
 ==== tests/cases/compiler/variableDeclarationInStrictMode1.ts (2 errors) ====
diff --git a/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols b/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols
index 4f56145951d..0aa90b3d89d 100644
--- a/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols
+++ b/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols
@@ -4,7 +4,7 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(wrappedAndRecursiveConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(wrappedAndRecursiveConstraints.ts, 2, 8))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(public data: T) { }
 >data : Symbol(C.data, Decl(wrappedAndRecursiveConstraints.ts, 3, 16))
@@ -24,7 +24,7 @@ class C<T extends Date> {
 
 interface Foo extends Date {
 >Foo : Symbol(Foo, Decl(wrappedAndRecursiveConstraints.ts, 7, 1))
->Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: string;
 >foo : Symbol(Foo.foo, Decl(wrappedAndRecursiveConstraints.ts, 9, 28))
diff --git a/tests/cases/compiler/binopAssignmentShouldHaveType.ts b/tests/cases/compiler/binopAssignmentShouldHaveType.ts
index e4325ba4bc6..07ee7b7fa6b 100644
--- a/tests/cases/compiler/binopAssignmentShouldHaveType.ts
+++ b/tests/cases/compiler/binopAssignmentShouldHaveType.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console;
 "use strict";
 module Test {
diff --git a/tests/cases/compiler/capturedLetConstInLoop13.ts b/tests/cases/compiler/capturedLetConstInLoop13.ts
index 0aa00b0e1a0..aa304fe21e6 100644
--- a/tests/cases/compiler/capturedLetConstInLoop13.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop13.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 class Main {
 
     constructor() {
diff --git a/tests/cases/compiler/classExpressionWithStaticProperties3.ts b/tests/cases/compiler/classExpressionWithStaticProperties3.ts
index 7c733c458be..344dc17f038 100644
--- a/tests/cases/compiler/classExpressionWithStaticProperties3.ts
+++ b/tests/cases/compiler/classExpressionWithStaticProperties3.ts
@@ -1,4 +1,5 @@
-//@target: es5
+// @lib: es5
+// @target: es5
 
 declare var console: any;
 const arr: {y(): number}[] = [];
diff --git a/tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts b/tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts
index 939a344f9bb..3b6ddb7dac2 100644
--- a/tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts
+++ b/tests/cases/compiler/classExpressionWithStaticPropertiesES63.ts
@@ -1,4 +1,5 @@
-//@target: es6
+// @lib: es5
+// @target: es6
 
 declare var console: any;
 const arr: {y(): number}[] = [];
diff --git a/tests/cases/compiler/classMemberInitializerWithLamdaScoping.ts b/tests/cases/compiler/classMemberInitializerWithLamdaScoping.ts
index c49c0b1a625..e634cbf7c5a 100644
--- a/tests/cases/compiler/classMemberInitializerWithLamdaScoping.ts
+++ b/tests/cases/compiler/classMemberInitializerWithLamdaScoping.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console: {
     log(msg?: any): void;
 };
diff --git a/tests/cases/compiler/classMemberInitializerWithLamdaScoping2.ts b/tests/cases/compiler/classMemberInitializerWithLamdaScoping2.ts
index 8453c3dae28..b17b1ca9d46 100644
--- a/tests/cases/compiler/classMemberInitializerWithLamdaScoping2.ts
+++ b/tests/cases/compiler/classMemberInitializerWithLamdaScoping2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @Filename: classMemberInitializerWithLamdaScoping2_0.ts
 var field1: string;
 
diff --git a/tests/cases/compiler/classMemberInitializerWithLamdaScoping5.ts b/tests/cases/compiler/classMemberInitializerWithLamdaScoping5.ts
index 104f1daea92..3d05a465f1a 100644
--- a/tests/cases/compiler/classMemberInitializerWithLamdaScoping5.ts
+++ b/tests/cases/compiler/classMemberInitializerWithLamdaScoping5.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console: {
     log(message?: any, ...optionalParams: any[]): void;
 };
diff --git a/tests/cases/compiler/classMemberWithMissingIdentifier2.ts b/tests/cases/compiler/classMemberWithMissingIdentifier2.ts
index e1618659797..6b1587361ab 100644
--- a/tests/cases/compiler/classMemberWithMissingIdentifier2.ts
+++ b/tests/cases/compiler/classMemberWithMissingIdentifier2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 class C { 
     public {[name:string]:VariableDeclaration};
 }
\ No newline at end of file
diff --git a/tests/cases/compiler/collisionRestParameterUnderscoreIUsage.ts b/tests/cases/compiler/collisionRestParameterUnderscoreIUsage.ts
index dbce96c1826..a41bb05d7e8 100644
--- a/tests/cases/compiler/collisionRestParameterUnderscoreIUsage.ts
+++ b/tests/cases/compiler/collisionRestParameterUnderscoreIUsage.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console: { log(msg?: string): void; };
 var _i = "This is what I'd expect to see";
 class Foo {
diff --git a/tests/cases/compiler/collisionSuperAndNameResolution.ts b/tests/cases/compiler/collisionSuperAndNameResolution.ts
index 8bdd1f3987d..4e08fe96982 100644
--- a/tests/cases/compiler/collisionSuperAndNameResolution.ts
+++ b/tests/cases/compiler/collisionSuperAndNameResolution.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var console: {
     log(message: any);
 }
diff --git a/tests/cases/compiler/collisionThisExpressionAndLocalVarInFunction.ts b/tests/cases/compiler/collisionThisExpressionAndLocalVarInFunction.ts
index dc704a32fb2..feb3fe25379 100644
--- a/tests/cases/compiler/collisionThisExpressionAndLocalVarInFunction.ts
+++ b/tests/cases/compiler/collisionThisExpressionAndLocalVarInFunction.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var console: {
     log(val: any);
 }
diff --git a/tests/cases/compiler/collisionThisExpressionAndLocalVarInLambda.ts b/tests/cases/compiler/collisionThisExpressionAndLocalVarInLambda.ts
index 99b13763d31..f70c6a5a457 100644
--- a/tests/cases/compiler/collisionThisExpressionAndLocalVarInLambda.ts
+++ b/tests/cases/compiler/collisionThisExpressionAndLocalVarInLambda.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare function alert(message?: any): void;
 
 var x = {
diff --git a/tests/cases/compiler/collisionThisExpressionAndNameResolution.ts b/tests/cases/compiler/collisionThisExpressionAndNameResolution.ts
index 5311e916e3c..d479498e225 100644
--- a/tests/cases/compiler/collisionThisExpressionAndNameResolution.ts
+++ b/tests/cases/compiler/collisionThisExpressionAndNameResolution.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var console : {
     log(message: any);
 }
diff --git a/tests/cases/compiler/collisionThisExpressionAndParameter.ts b/tests/cases/compiler/collisionThisExpressionAndParameter.ts
index fa0c84684a2..fc7410bcf7d 100644
--- a/tests/cases/compiler/collisionThisExpressionAndParameter.ts
+++ b/tests/cases/compiler/collisionThisExpressionAndParameter.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 class Foo {
     x() {
         var _this = 10; // Local var. No this capture in x(), so no conflict.
@@ -31,20 +32,20 @@ class Foo {
     }
 }
 class Foo1 {
-    constructor(_this: number) { // Error
-        var x2 = {
-            doStuff: (callback) => () => {
-                return callback(this);
-            }
-        }
+    constructor(_this: number) { // Error
+        var x2 = {
+            doStuff: (callback) => () => {
+                return callback(this);
+            }
+        }
     }
 }
 declare var console: {
     log(msg: any);
 }
 
-function f1(_this: number) {
-    x => { console.log(this.x); };
+function f1(_this: number) {
+    x => { console.log(this.x); };
 }
 
 declare class Foo2 {
@@ -56,12 +57,12 @@ declare function f2(_this: number); // no error
 class Foo3 {
     constructor(_this: string); // no code gen - no error
     constructor(_this: number); // no code gen - no error
-    constructor(_this: any) { // Error
-        var x2 = {
-            doStuff: (callback) => () => {
-                return callback(this);
-            }
-        }
+    constructor(_this: any) { // Error
+        var x2 = {
+            doStuff: (callback) => () => {
+                return callback(this);
+            }
+        }
     }
 
     z(_this: string); // no code gen - no error
@@ -78,8 +79,8 @@ declare var console: {
 
 function f3(_this: number); // no code gen - no error
 function f3(_this: string); // no code gen - no error
-function f3(_this: any) {
-    x => { console.log(this.x); };
+function f3(_this: any) {
+    x => { console.log(this.x); };
 }
 
 declare class Foo4 {
diff --git a/tests/cases/compiler/constEnumErrors.ts b/tests/cases/compiler/constEnumErrors.ts
index 87e6b7ccb98..be45ed83632 100644
--- a/tests/cases/compiler/constEnumErrors.ts
+++ b/tests/cases/compiler/constEnumErrors.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 const enum E {
     A
 }
diff --git a/tests/cases/compiler/contextualTypingOfTooShortOverloads.ts b/tests/cases/compiler/contextualTypingOfTooShortOverloads.ts
index 6fa88a1e559..cbc0769bd66 100644
--- a/tests/cases/compiler/contextualTypingOfTooShortOverloads.ts
+++ b/tests/cases/compiler/contextualTypingOfTooShortOverloads.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // small repro from #11875
 var use: Overload;
 use((req, res) => {});
diff --git a/tests/cases/compiler/decoratorWithUnderscoreMethod.ts b/tests/cases/compiler/decoratorWithUnderscoreMethod.ts
index e6551c91284..2cc8ff88d46 100644
--- a/tests/cases/compiler/decoratorWithUnderscoreMethod.ts
+++ b/tests/cases/compiler/decoratorWithUnderscoreMethod.ts
@@ -1,4 +1,5 @@
-// @noemithelpers: true
+// @lib: es5
+// @noemithelpers: true
 // @experimentaldecorators: true
 
 declare var console : { log(arg: string): void };
diff --git a/tests/cases/compiler/fatarrowfunctions.ts b/tests/cases/compiler/fatarrowfunctions.ts
index 2afa4c54b4a..0e794ac8886 100644
--- a/tests/cases/compiler/fatarrowfunctions.ts
+++ b/tests/cases/compiler/fatarrowfunctions.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 
 function foo(x:any) {
 	return x();
diff --git a/tests/cases/compiler/fatarrowfunctionsInFunctions.ts b/tests/cases/compiler/fatarrowfunctionsInFunctions.ts
index 67bbfeb1639..9d1a5edc893 100644
--- a/tests/cases/compiler/fatarrowfunctionsInFunctions.ts
+++ b/tests/cases/compiler/fatarrowfunctionsInFunctions.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare function setTimeout(expression: any, msec?: number, language?: any): number;
 
 var messenger = {
diff --git a/tests/cases/compiler/genericMethodOverspecialization.ts b/tests/cases/compiler/genericMethodOverspecialization.ts
index 60dc46980e8..241f4941b91 100644
--- a/tests/cases/compiler/genericMethodOverspecialization.ts
+++ b/tests/cases/compiler/genericMethodOverspecialization.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var names = ["list", "table1", "table2", "table3", "summary"];
 
 interface HTMLElement {
diff --git a/tests/cases/compiler/interfaceExtendsClass1.ts b/tests/cases/compiler/interfaceExtendsClass1.ts
index 64c51563668..8c84eba81b0 100644
--- a/tests/cases/compiler/interfaceExtendsClass1.ts
+++ b/tests/cases/compiler/interfaceExtendsClass1.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 class Control {
     private state: any;
 }
diff --git a/tests/cases/compiler/lambdaArgCrash.ts b/tests/cases/compiler/lambdaArgCrash.ts
index c2e2bba4117..3151c2521ac 100644
--- a/tests/cases/compiler/lambdaArgCrash.ts
+++ b/tests/cases/compiler/lambdaArgCrash.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 class Event {
 
 	 private _listeners: any[] = [];
diff --git a/tests/cases/compiler/letConstMatchingParameterNames.ts b/tests/cases/compiler/letConstMatchingParameterNames.ts
index e749912ad82..ceb3773bf46 100644
--- a/tests/cases/compiler/letConstMatchingParameterNames.ts
+++ b/tests/cases/compiler/letConstMatchingParameterNames.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @target: es5
 let parent = true;
 const parent2 = true;
diff --git a/tests/cases/compiler/maximum10SpellingSuggestions.ts b/tests/cases/compiler/maximum10SpellingSuggestions.ts
index 7aa27dc1e2a..e857a66d8ea 100644
--- a/tests/cases/compiler/maximum10SpellingSuggestions.ts
+++ b/tests/cases/compiler/maximum10SpellingSuggestions.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // 10 bobs on the first line
 // the last two bobs should not have did-you-mean spelling suggestions
 var blob;
diff --git a/tests/cases/compiler/moduleVariables.ts b/tests/cases/compiler/moduleVariables.ts
index 0b813f75ce4..b53b43a5ba2 100644
--- a/tests/cases/compiler/moduleVariables.ts
+++ b/tests/cases/compiler/moduleVariables.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console: any;
  
 var x = 1;
diff --git a/tests/cases/compiler/module_augmentExistingAmbientVariable.ts b/tests/cases/compiler/module_augmentExistingAmbientVariable.ts
index 53a2842ed3f..4972714a82f 100644
--- a/tests/cases/compiler/module_augmentExistingAmbientVariable.ts
+++ b/tests/cases/compiler/module_augmentExistingAmbientVariable.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console: any;
 
 module console {
diff --git a/tests/cases/compiler/module_augmentExistingVariable.ts b/tests/cases/compiler/module_augmentExistingVariable.ts
index bf192c8d113..266c3ad4d7f 100644
--- a/tests/cases/compiler/module_augmentExistingVariable.ts
+++ b/tests/cases/compiler/module_augmentExistingVariable.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var console: any;
 
 module console {
diff --git a/tests/cases/compiler/noCollisionThisExpressionAndLocalVarInFunction.ts b/tests/cases/compiler/noCollisionThisExpressionAndLocalVarInFunction.ts
index 1b6c6270cb5..6e931b77de2 100644
--- a/tests/cases/compiler/noCollisionThisExpressionAndLocalVarInFunction.ts
+++ b/tests/cases/compiler/noCollisionThisExpressionAndLocalVarInFunction.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var console: {
     log(val: any);
 }
diff --git a/tests/cases/compiler/noCollisionThisExpressionInFunctionAndVarInGlobal.ts b/tests/cases/compiler/noCollisionThisExpressionInFunctionAndVarInGlobal.ts
index 15b2a189328..3f23fcf1258 100644
--- a/tests/cases/compiler/noCollisionThisExpressionInFunctionAndVarInGlobal.ts
+++ b/tests/cases/compiler/noCollisionThisExpressionInFunctionAndVarInGlobal.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var console: {
     log(val: any);
 }
diff --git a/tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts b/tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts
index 23cd2ba45f8..b24b174db2c 100644
--- a/tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts
+++ b/tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 1..toString();
 1.0.toString();
 1.toString();
diff --git a/tests/cases/compiler/objectLitArrayDeclNoNew.ts b/tests/cases/compiler/objectLitArrayDeclNoNew.ts
index d4e0d6e9468..f089a99e67b 100644
--- a/tests/cases/compiler/objectLitArrayDeclNoNew.ts
+++ b/tests/cases/compiler/objectLitArrayDeclNoNew.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare var console;
 "use strict";
 module Test {
diff --git a/tests/cases/compiler/overloadingStaticFunctionsInFunctions.ts b/tests/cases/compiler/overloadingStaticFunctionsInFunctions.ts
index 4e07771c8d1..4e530469e4b 100644
--- a/tests/cases/compiler/overloadingStaticFunctionsInFunctions.ts
+++ b/tests/cases/compiler/overloadingStaticFunctionsInFunctions.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 function boo {
   static test()
   static test(name:string)
diff --git a/tests/cases/compiler/recursiveClassReferenceTest.ts b/tests/cases/compiler/recursiveClassReferenceTest.ts
index d62923b0fe8..0c4619eb242 100644
--- a/tests/cases/compiler/recursiveClassReferenceTest.ts
+++ b/tests/cases/compiler/recursiveClassReferenceTest.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 // Scenario 1: Test reqursive function call with "this" parameter
 // Scenario 2: Test recursive function call with cast and "this" parameter
diff --git a/tests/cases/compiler/recursiveNamedLambdaCall.ts b/tests/cases/compiler/recursiveNamedLambdaCall.ts
index 6b940491704..0c0a28d15e4 100644
--- a/tests/cases/compiler/recursiveNamedLambdaCall.ts
+++ b/tests/cases/compiler/recursiveNamedLambdaCall.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 var promise = function( obj ) {
 	
 		if ( top && top.doScroll ) {
diff --git a/tests/cases/compiler/recursiveSpecializationOfExtendedTypeWithError.ts b/tests/cases/compiler/recursiveSpecializationOfExtendedTypeWithError.ts
index a1353d180f4..7a4666114c7 100644
--- a/tests/cases/compiler/recursiveSpecializationOfExtendedTypeWithError.ts
+++ b/tests/cases/compiler/recursiveSpecializationOfExtendedTypeWithError.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 interface HTMLSelectElement {
     options: HTMLSelectElement;
     <A>(name: A): any;
diff --git a/tests/cases/compiler/selfInLambdas.ts b/tests/cases/compiler/selfInLambdas.ts
index 659b77fa458..243b2470e8b 100644
--- a/tests/cases/compiler/selfInLambdas.ts
+++ b/tests/cases/compiler/selfInLambdas.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @noImplicitAny: true
 // @noImplicitThis: true
 
diff --git a/tests/cases/compiler/selfRef.ts b/tests/cases/compiler/selfRef.ts
index f78fef24c93..1f8a079789c 100644
--- a/tests/cases/compiler/selfRef.ts
+++ b/tests/cases/compiler/selfRef.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 module M
 {
     export class Test
diff --git a/tests/cases/compiler/shebangError.ts b/tests/cases/compiler/shebangError.ts
index 91a27a65aa0..c700e7f3716 100644
--- a/tests/cases/compiler/shebangError.ts
+++ b/tests/cases/compiler/shebangError.ts
@@ -1,2 +1,3 @@
+// @lib: es5
 var foo = 'Shebang is only allowed on the first line';
 #!/usr/bin/env node
\ No newline at end of file
diff --git a/tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts b/tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts
index 756882ecc3f..a4ddd242d4a 100644
--- a/tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts
+++ b/tests/cases/compiler/sourceMap-StringLiteralWithNewLine.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @target: ES3
 // @sourcemap: true
 
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern.ts
index cd1ad012b25..9754508418d 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern2.ts
index 597f40afe86..3a65e22a560 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPattern2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.ts
index 36c3c8cb48c..738ca45a268 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.ts
index 4e0e5d053b3..0e4c3a9604f 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern.ts
index 7d5471db324..7b382322a8a 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern2.ts
index 3e018b2a6d5..38debd76a5d 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPattern2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues.ts
index 22c9ecdf66d..2b9bcdf335d 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues2.ts
index 0240a82c40b..168bb56d25e 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForObjectBindingPatternDefaultValues2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern.ts
index f2fb461f443..f09df156b7e 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern2.ts
index 365a030f8e9..022dd5acb88 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPattern2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.ts
index a619fc1c42f..5f37fd6f5c8 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.ts
index ac0c8774567..d82e126ac8c 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern.ts
index df822f89bc0..5b1d7743794 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern2.ts
index 7f71e7d6bdd..629f14960c3 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPattern2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues.ts
index d8f88189c01..67485eda08f 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues2.ts b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues2.ts
index 01d2f6133a3..5f2de97ee30 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPattern.ts
index 062acd823ac..e8093d8a5c6 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPatternDefaultValues.ts
index c9dd735e8b6..2eb0ebf5c30 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParameterNestedObjectBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPattern.ts
index 0f52806dd16..492d4346fde 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 interface Robot {
     name: string;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPatternDefaultValues.ts
index 6fc9c5a605e..1f5ec9c39f6 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParameterObjectBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 interface Robot {
     name?: string;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern.ts
index 731dc7f2657..f0d0417dc93 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern2.ts b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern2.ts
index 07c2a24e70e..a992d3439ad 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPattern2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.ts
index 345d3965156..dad5b98b849 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.ts b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.ts
index 83f95c09c02..d1aed4c5f1d 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement.ts
index 88e49498f60..c03466c5370 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 interface Robot {
     name: string;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement1.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement1.ts
index 3697402bbcf..56e653415b9 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement1.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatement1.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 interface Robot {
     name: string;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.ts
index 3ac03143aa2..048ba0d67e4 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.ts
index 27497f2c220..7de9d857705 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.ts
index 78ed29c397b..26575e45667 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.ts
index fb942310389..c66a94144ea 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.ts
index 4b4ef07d232..980be704333 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.ts
index 253d96d4b35..92fa65d2a41 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: any): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementDefaultValues.ts
index b95e7e5464a..f04bb27937c 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 interface Robot {
     name: string;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPattern.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPattern.ts
index a40e5f11ebb..f8c846ac4b3 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPattern.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPattern.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPatternWithDefaultValues.ts b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPatternWithDefaultValues.ts
index 95eda6f2050..2c3980e6926 100644
--- a/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPatternWithDefaultValues.ts
+++ b/tests/cases/compiler/sourceMapValidationDestructuringVariableStatementNestedObjectBindingPatternWithDefaultValues.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @sourcemap: true
 declare var console: {
     log(msg: string): void;
diff --git a/tests/cases/compiler/staticInstanceResolution.ts b/tests/cases/compiler/staticInstanceResolution.ts
index 50e9f5a1bdc..01c6726aff0 100644
--- a/tests/cases/compiler/staticInstanceResolution.ts
+++ b/tests/cases/compiler/staticInstanceResolution.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 class Comment {
 
     public getDocCommentText()
diff --git a/tests/cases/compiler/staticsInAFunction.ts b/tests/cases/compiler/staticsInAFunction.ts
index d546c17d912..3b6a3a23261 100644
--- a/tests/cases/compiler/staticsInAFunction.ts
+++ b/tests/cases/compiler/staticsInAFunction.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 function boo{
    static test()
    static test(name:string)
diff --git a/tests/cases/compiler/unusedLocalProperty.ts b/tests/cases/compiler/unusedLocalProperty.ts
index fdd33116135..5ff404ac8b9 100644
--- a/tests/cases/compiler/unusedLocalProperty.ts
+++ b/tests/cases/compiler/unusedLocalProperty.ts
@@ -1,4 +1,5 @@
-//@noUnusedLocals:true
+// @lib: es5
+// @noUnusedLocals: true
 declare var console: { log(msg: any): void; }
 class Animal {
     constructor(private species: string) {
diff --git a/tests/cases/compiler/unusedLocalsAndObjectSpread.ts b/tests/cases/compiler/unusedLocalsAndObjectSpread.ts
index b042b412c8e..c6aab5ab598 100644
--- a/tests/cases/compiler/unusedLocalsAndObjectSpread.ts
+++ b/tests/cases/compiler/unusedLocalsAndObjectSpread.ts
@@ -1,4 +1,5 @@
-//@noUnusedLocals:true
+// @lib: es5
+// @noUnusedLocals: true
 
 declare var console: { log(a: any): void };
 
diff --git a/tests/cases/compiler/variableDeclaratorResolvedDuringContextualTyping.ts b/tests/cases/compiler/variableDeclaratorResolvedDuringContextualTyping.ts
index dbb1a653c33..e794087e01e 100644
--- a/tests/cases/compiler/variableDeclaratorResolvedDuringContextualTyping.ts
+++ b/tests/cases/compiler/variableDeclaratorResolvedDuringContextualTyping.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 module WinJS {
     export interface ValueCallback {
         (value: any): any;
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts
index 7bc540e1e2a..43c1f7182b6 100644
--- a/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts
+++ b/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts
@@ -11,7 +11,6 @@ export function foo() { return "foo" }
 export function backup() { return "backup"; }
 
 // @filename: 2.ts
-declare var console: any;
 class C {
     private myModule = import("./0");
     method() {
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNoModuleKindSpecified.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNoModuleKindSpecified.ts
index 856f763eb56..414fe106314 100644
--- a/tests/cases/conformance/dynamicImport/importCallExpressionNoModuleKindSpecified.ts
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionNoModuleKindSpecified.ts
@@ -9,7 +9,6 @@ export function foo() { return "foo" }
 export function backup() { return "backup"; }
 
 // @filename: 2.ts
-declare var console: any;
 class C {
     private myModule = import("./0");
     method() {
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts
index 111abd70ac3..c044d60a680 100644
--- a/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts
@@ -1,3 +1,4 @@
+//@lib: es2015
 //@target: ES6
 function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
 takeFirstTwoEntries(...new Map([["", 0], ["hello", true]]));
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of39.ts b/tests/cases/conformance/es6/for-ofStatements/for-of39.ts
index 1d3ae5fc76c..1b6d303f574 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of39.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of39.ts
@@ -1,4 +1,5 @@
-//@target: ES6
+//@lib: es2015
+//@target: ES6
 var map = new Map([["", true], ["", 0]]);
 for (var [k, v] of map) {
     k;
diff --git a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignment.ts b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignment.ts
index 38782100166..a5f5d774157 100644
--- a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignment.ts
+++ b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignment.ts
@@ -1,4 +1,5 @@
-var id: number = 10000;
+// @lib: es5
+var id: number = 10000;
 var name: string = "my name";
 
 var person: { name: string; id: number } = { name, id };
diff --git a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentES6.ts b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentES6.ts
index 19fd21b47b5..bfd20d3db8a 100644
--- a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentES6.ts
+++ b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentES6.ts
@@ -1,4 +1,5 @@
-// @target: es6
+// @lib: es2015
+// @target: es6
 var id: number = 10000;
 var name: string = "my name";
 
diff --git a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts
index 55f10aec932..7e58ab34bdd 100644
--- a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts
+++ b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts
@@ -1,4 +1,5 @@
-var id: number = 10000;
+// @lib: es5
+var id: number = 10000;
 var name: string = "my name";
 
 var person: { b: string; id: number } = { name, id };  // error
diff --git a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts
index 104be41a839..9757e65e7b9 100644
--- a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts
+++ b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts
@@ -1,4 +1,5 @@
-var id: number = 10000;
+// @lib: es5
+var id: number = 10000;
 var name: string = "my name";
 
 var person: { b: string; id: number } = { name, id };  // error
diff --git a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument.ts b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument.ts
index c50c4e3fbdf..5f3b6514a69 100644
--- a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument.ts
+++ b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument.ts
@@ -1,4 +1,5 @@
-var id: number = 10000;
+// @lib: es5
+var id: number = 10000;
 var name: string = "my name";
 
 var person = { name, id };
diff --git a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument2.ts b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument2.ts
index 45c248a5911..883d421466d 100644
--- a/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument2.ts
+++ b/tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesFunctionArgument2.ts
@@ -1,4 +1,5 @@
-var id: number = 10000;
+// @lib: es5
+var id: number = 10000;
 var name: string = "my name";
 
 var person = { name, id };
diff --git a/tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration17.ts b/tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration17.ts
index e4fc27adccd..a709f7d7bcc 100644
--- a/tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration17.ts
+++ b/tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration17.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 declare class Enumerator {
     public atEnd(): boolean;
     public moveNext();
diff --git a/tests/cases/conformance/parser/ecmascript5/Expressions/parserMemberAccessAfterPostfixExpression1.ts b/tests/cases/conformance/parser/ecmascript5/Expressions/parserMemberAccessAfterPostfixExpression1.ts
index 3a61130d429..887bfadd3a2 100644
--- a/tests/cases/conformance/parser/ecmascript5/Expressions/parserMemberAccessAfterPostfixExpression1.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Expressions/parserMemberAccessAfterPostfixExpression1.ts
@@ -1 +1,2 @@
+// @lib: es5
 a--.toString()
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts b/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts
index 31753a8ac72..4cb9c6cb75d 100644
--- a/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts
+++ b/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts
@@ -1,4 +1,5 @@
-//
+// @lib: es5
+//
 // Copyright (c) Microsoft Corporation.  All rights reserved.
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/tests/cases/conformance/parser/ecmascript5/parserRealSource5.ts b/tests/cases/conformance/parser/ecmascript5/parserRealSource5.ts
index 32b29e574d2..c422a7eed3a 100644
--- a/tests/cases/conformance/parser/ecmascript5/parserRealSource5.ts
+++ b/tests/cases/conformance/parser/ecmascript5/parserRealSource5.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0. 
 // See LICENSE.txt in the project root for complete license information.
 
diff --git a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts
index 9ef2f06cdfc..5a12efa7797 100644
--- a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts
+++ b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 function foo(obj: { name?: string; id: number }) { }
 var name:any, id: any;
 foo({ name?, id? });
\ No newline at end of file
diff --git a/tests/cases/conformance/references/library-reference-2.ts b/tests/cases/conformance/references/library-reference-2.ts
index 9ac7cd4f4d3..09ed15f653d 100644
--- a/tests/cases/conformance/references/library-reference-2.ts
+++ b/tests/cases/conformance/references/library-reference-2.ts
@@ -1,7 +1,7 @@
 // @noImplicitReferences: true
 // @traceResolution: true
 // @typeRoots: /types
-// @currentDirectory: test
+// @currentDirectory: /test
 
 // package.json in a primary reference can refer to another file
 
diff --git a/tests/cases/conformance/types/members/objectTypeHidingMembersOfExtendedObject.ts b/tests/cases/conformance/types/members/objectTypeHidingMembersOfExtendedObject.ts
index b18dc498bb6..71c5e195bee 100644
--- a/tests/cases/conformance/types/members/objectTypeHidingMembersOfExtendedObject.ts
+++ b/tests/cases/conformance/types/members/objectTypeHidingMembersOfExtendedObject.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @skipDefaultLibCheck: false
 class A {
     foo: string;
diff --git a/tests/cases/conformance/types/members/objectTypeWithStringIndexerHidingObjectIndexer.ts b/tests/cases/conformance/types/members/objectTypeWithStringIndexerHidingObjectIndexer.ts
index 797ad2cb091..971fe01987b 100644
--- a/tests/cases/conformance/types/members/objectTypeWithStringIndexerHidingObjectIndexer.ts
+++ b/tests/cases/conformance/types/members/objectTypeWithStringIndexerHidingObjectIndexer.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @skipDefaultLibCheck: false
 // object types can define string indexers that are more specific than the default 'any' that would be returned
 // no errors expected below 
diff --git a/tests/cases/conformance/types/never/neverInference.ts b/tests/cases/conformance/types/never/neverInference.ts
index 1258a35e3d3..0501f9540c9 100644
--- a/tests/cases/conformance/types/never/neverInference.ts
+++ b/tests/cases/conformance/types/never/neverInference.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 // @strict: true
 
 declare function f<T>(x: T[]): T;
diff --git a/tests/cases/conformance/types/spread/objectSpreadNegativeParse.ts b/tests/cases/conformance/types/spread/objectSpreadNegativeParse.ts
index 47fd787ec9a..4d0aafab7a1 100644
--- a/tests/cases/conformance/types/spread/objectSpreadNegativeParse.ts
+++ b/tests/cases/conformance/types/spread/objectSpreadNegativeParse.ts
@@ -1,3 +1,4 @@
+// @lib: es5
 let o7 = { ...o? };
 let o8 = { ...*o };
 let o9 = { ...matchMedia() { }};