diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index fe2ce42652a..62756388dc4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1238,17 +1238,25 @@ namespace ts {
                                     // local types not visible outside the function body
                                     : false;
                             }
-                            if (meaning & result.flags & SymbolFlags.FunctionScopedVariable) {
-                                // parameters are visible only inside function body, parameter list and return type
-                                // technically for parameter list case here we might mix parameters and variables declared in function,
-                                // however it is detected separately when checking initializers of parameters
-                                // to make sure that they reference no variables declared after them.
-                                useResult =
-                                    lastLocation.kind === SyntaxKind.Parameter ||
-                                    (
-                                        lastLocation === (<FunctionLikeDeclaration>location).type &&
-                                        !!findAncestor(result.valueDeclaration, isParameter)
-                                    );
+                            if (meaning & result.flags & SymbolFlags.Variable) {
+                                // expression inside parameter will lookup as normal variable scope when targeting es2015+
+                                const functionLocation = <FunctionLikeDeclaration>location;
+                                if (compilerOptions.target && compilerOptions.target >= ScriptTarget.ES2015 && isParameter(lastLocation) &&
+                                    functionLocation.body && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
+                                    useResult = false;
+                                }
+                                else if (result.flags & SymbolFlags.FunctionScopedVariable) {
+                                    // parameters are visible only inside function body, parameter list and return type
+                                    // technically for parameter list case here we might mix parameters and variables declared in function,
+                                    // however it is detected separately when checking initializers of parameters
+                                    // to make sure that they reference no variables declared after them.
+                                    useResult =
+                                        lastLocation.kind === SyntaxKind.Parameter ||
+                                        (
+                                            lastLocation === (<FunctionLikeDeclaration>location).type &&
+                                            !!findAncestor(result.valueDeclaration, isParameter)
+                                        );
+                                }
                             }
                         }
                         else if (location.kind === SyntaxKind.ConditionalType) {
@@ -26103,8 +26111,11 @@ namespace ts {
                     if (!checkTypeAssignableTo(typeWithThis, baseWithThis, /*errorNode*/ undefined)) {
                         issueMemberSpecificError(node, typeWithThis, baseWithThis, Diagnostics.Class_0_incorrectly_extends_base_class_1);
                     }
-                    checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node,
-                        Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+                    else {
+                        // Report static side error only when instance type is assignable
+                        checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node,
+                            Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+                    }
                     if (baseConstructorType.flags & TypeFlags.TypeVariable && !isMixinConstructorType(staticType)) {
                         error(node.name || node, Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
                     }
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index fe54402d434..6b4b3a5c510 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -41,20 +41,23 @@ namespace ts {
     export function getOutputPathsFor(sourceFile: SourceFile | Bundle, host: EmitHost, forceDtsPaths: boolean): EmitFileNames {
         const options = host.getCompilerOptions();
         if (sourceFile.kind === SyntaxKind.Bundle) {
-            const jsFilePath = options.outFile || options.out!;
-            const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
-            const declarationFilePath = (forceDtsPaths || getEmitDeclarations(options)) ? removeFileExtension(jsFilePath) + Extension.Dts : undefined;
-            const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
+            const outPath = options.outFile || options.out!;
+            const jsFilePath = options.emitDeclarationOnly ? undefined : outPath;
+            const sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options);
+            const declarationFilePath = (forceDtsPaths || getEmitDeclarations(options)) ? removeFileExtension(outPath) + Extension.Dts : undefined;
+            const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
             const bundleInfoPath = options.references && jsFilePath ? (removeFileExtension(jsFilePath) + infoExtension) : undefined;
             return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, bundleInfoPath };
         }
         else {
-            const jsFilePath = getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile, options));
-            const sourceMapFilePath = isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options);
+            const ownOutputFilePath = getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile, options));
+            // If json file emits to the same location skip writing it, if emitDeclarationOnly skip writing it
+            const jsFilePath = options.emitDeclarationOnly ? undefined : ownOutputFilePath;
+            const sourceMapFilePath = !jsFilePath || isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options);
             // For legacy reasons (ie, we have baselines capturing the behavior), js files don't report a .d.ts output path - this would only matter if `declaration` and `allowJs` were both on, which is currently an error
             const isJs = isSourceFileJS(sourceFile);
             const declarationFilePath = ((forceDtsPaths || getEmitDeclarations(options)) && !isJs) ? getDeclarationEmitOutputFilePath(sourceFile.fileName, host) : undefined;
-            const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
+            const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
             return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, bundleInfoPath: undefined };
         }
     }
@@ -135,27 +138,33 @@ namespace ts {
 
             if (!emitSkipped && emittedFilesList) {
                 if (!emitOnlyDtsFiles) {
-                    emittedFilesList.push(jsFilePath);
-                }
-                if (sourceMapFilePath) {
-                    emittedFilesList.push(sourceMapFilePath);
+                    if (jsFilePath) {
+                        emittedFilesList.push(jsFilePath);
+                    }
+                    if (sourceMapFilePath) {
+                        emittedFilesList.push(sourceMapFilePath);
+                    }
+                    if (bundleInfoPath) {
+                        emittedFilesList.push(bundleInfoPath);
+                    }
                 }
                 if (declarationFilePath) {
                     emittedFilesList.push(declarationFilePath);
                 }
-                if (bundleInfoPath) {
-                    emittedFilesList.push(bundleInfoPath);
+                if (declarationMapPath) {
+                    emittedFilesList.push(declarationMapPath);
                 }
             }
         }
 
-        function emitJsFileOrBundle(sourceFileOrBundle: SourceFile | Bundle, jsFilePath: string, sourceMapFilePath: string | undefined, bundleInfoPath: string | undefined) {
-            // Make sure not to write js file and source map file if any of them cannot be written
-            if (host.isEmitBlocked(jsFilePath) || compilerOptions.noEmit || compilerOptions.emitDeclarationOnly) {
-                emitSkipped = true;
+        function emitJsFileOrBundle(sourceFileOrBundle: SourceFile | Bundle, jsFilePath: string | undefined, sourceMapFilePath: string | undefined, bundleInfoPath: string | undefined) {
+            if (emitOnlyDtsFiles || !jsFilePath) {
                 return;
             }
-            if (emitOnlyDtsFiles) {
+
+            // Make sure not to write js file and source map file if any of them cannot be written
+            if ((jsFilePath && host.isEmitBlocked(jsFilePath)) || compilerOptions.noEmit) {
+                emitSkipped = true;
                 return;
             }
             // Transform the source files
diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
index 5312efb5aac..00e787c421b 100644
--- a/src/compiler/transformers/declarations.ts
+++ b/src/compiler/transformers/declarations.ts
@@ -275,7 +275,7 @@ namespace ts {
                     else {
                         if (isBundledEmit && contains((node as Bundle).sourceFiles, file)) return; // Omit references to files which are being merged
                         const paths = getOutputPathsFor(file, host, /*forceDtsPaths*/ true);
-                        declFileName = paths.declarationFilePath || paths.jsFilePath;
+                        declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName;
                     }
 
                     if (declFileName) {
diff --git a/src/compiler/tsbuild.ts b/src/compiler/tsbuild.ts
index 5d27e6a79f6..c2215b22ebf 100644
--- a/src/compiler/tsbuild.ts
+++ b/src/compiler/tsbuild.ts
@@ -1066,6 +1066,9 @@ namespace ts {
                 type: UpToDateStatusType.UpToDate,
                 newestDeclarationFileContentChangedTime: anyDtsChanged ? maximumDate : newestDeclarationFileContentChangedTime
             };
+            if (options.watch) {
+                diagnostics.removeKey(proj);
+            }
             projectStatus.setValue(proj, status);
             return resultFlags;
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index ae75290d56e..564e74fc4d3 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -3245,7 +3245,7 @@ namespace ts {
     }
 
     export interface EmitFileNames {
-        jsFilePath: string;
+        jsFilePath: string | undefined;
         sourceMapFilePath: string | undefined;
         declarationFilePath: string | undefined;
         declarationMapPath: string | undefined;
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index b23b01bcccb..34d32eb2cc0 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -486,7 +486,7 @@ namespace ts.server {
 
         private readonly hostConfiguration: HostConfiguration;
         private safelist: SafeList = defaultTypeSafeList;
-        private legacySafelist: { [key: string]: string } = {};
+        private readonly legacySafelist = createMap<string>();
 
         private pendingProjectUpdates = createMap<Project>();
         /* @internal */
@@ -638,14 +638,14 @@ namespace ts.server {
                 this.safelist = raw.typesMap;
                 for (const key in raw.simpleMap) {
                     if (raw.simpleMap.hasOwnProperty(key)) {
-                        this.legacySafelist[key] = raw.simpleMap[key].toLowerCase();
+                        this.legacySafelist.set(key, raw.simpleMap[key].toLowerCase());
                     }
                 }
             }
             catch (e) {
                 this.logger.info(`Error loading types map: ${e}`);
                 this.safelist = defaultTypeSafeList;
-                this.legacySafelist = {};
+                this.legacySafelist.clear();
             }
         }
 
@@ -2723,13 +2723,13 @@ namespace ts.server {
                         if (fileExtensionIs(baseName, "js")) {
                             const inferredTypingName = removeFileExtension(baseName);
                             const cleanedTypingName = removeMinAndVersionNumbers(inferredTypingName);
-                            if (this.legacySafelist[cleanedTypingName]) {
+                            const typeName = this.legacySafelist.get(cleanedTypingName);
+                            if (typeName !== undefined) {
                                 this.logger.info(`Excluded '${normalizedNames[i]}' because it matched ${cleanedTypingName} from the legacy safelist`);
                                 excludedFiles.push(normalizedNames[i]);
                                 // *exclude* it from the project...
                                 exclude = true;
                                 // ... but *include* it in the list of types to acquire
-                                const typeName = this.legacySafelist[cleanedTypingName];
                                 // Same best-effort dedupe as above
                                 if (typeAcqInclude.indexOf(typeName) < 0) {
                                     typeAcqInclude.push(typeName);
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 578f55f5c68..2f6d68c52f4 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -185,20 +185,20 @@ namespace ts.codefix {
 
             const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
             if (defaultInfo && defaultInfo.name === symbolName && skipAlias(defaultInfo.symbol, checker) === exportedSymbol) {
-                result.push({ moduleSymbol, importKind: defaultInfo.kind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(defaultInfo.symbol) });
+                result.push({ moduleSymbol, importKind: defaultInfo.kind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(defaultInfo.symbol, checker) });
             }
 
             for (const exported of checker.getExportsOfModule(moduleSymbol)) {
                 if (exported.name === symbolName && skipAlias(exported, checker) === exportedSymbol) {
-                    result.push({ moduleSymbol, importKind: ImportKind.Named, exportedSymbolIsTypeOnly: isTypeOnlySymbol(exported) });
+                    result.push({ moduleSymbol, importKind: ImportKind.Named, exportedSymbolIsTypeOnly: isTypeOnlySymbol(exported, checker) });
                 }
             }
         });
         return result;
     }
 
-    function isTypeOnlySymbol(s: Symbol): boolean {
-        return !(s.flags & SymbolFlags.Value);
+    function isTypeOnlySymbol(s: Symbol, checker: TypeChecker): boolean {
+        return !(skipAlias(s, checker).flags & SymbolFlags.Value);
     }
 
     function getFixForImport(
@@ -398,7 +398,7 @@ namespace ts.codefix {
         // Maps symbol id to info for modules providing that symbol (original export + re-exports).
         const originalSymbolToExportInfos = createMultiMap<SymbolExportInfo>();
         function addSymbol(moduleSymbol: Symbol, exportedSymbol: Symbol, importKind: ImportKind): void {
-            originalSymbolToExportInfos.add(getUniqueSymbolId(exportedSymbol, checker).toString(), { moduleSymbol, importKind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(exportedSymbol) });
+            originalSymbolToExportInfos.add(getUniqueSymbolId(exportedSymbol, checker).toString(), { moduleSymbol, importKind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(exportedSymbol, checker) });
         }
         forEachExternalModuleToImportFrom(checker, sourceFile, program.getSourceFiles(), moduleSymbol => {
             cancellationToken.throwIfCancellationRequested();
@@ -424,7 +424,7 @@ namespace ts.codefix {
         if (!exported) return undefined;
         const { symbol, kind } = exported;
         const info = getDefaultExportInfoWorker(symbol, moduleSymbol, checker, compilerOptions);
-        return info && { symbol, symbolForMeaning: info.symbolForMeaning, name: info.name, kind };
+        return info && { symbol, kind, ...info };
     }
 
     function getDefaultLikeExportWorker(moduleSymbol: Symbol, checker: TypeChecker): { readonly symbol: Symbol, readonly kind: ImportKind.Default | ImportKind.Equals } | undefined {
diff --git a/src/testRunner/unittests/tsbuild.ts b/src/testRunner/unittests/tsbuild.ts
index 34e83eab43e..c96e12618f4 100644
--- a/src/testRunner/unittests/tsbuild.ts
+++ b/src/testRunner/unittests/tsbuild.ts
@@ -337,8 +337,10 @@ export class cNew {}`);
                 assert.deepEqual(host.traces, [
                     "TSFILE: /src/core/anotherModule.js",
                     "TSFILE: /src/core/anotherModule.d.ts",
+                    "TSFILE: /src/core/anotherModule.d.ts.map",
                     "TSFILE: /src/core/index.js",
                     "TSFILE: /src/core/index.d.ts",
+                    "TSFILE: /src/core/index.d.ts.map",
                     "TSFILE: /src/logic/index.js",
                     "TSFILE: /src/logic/index.js.map",
                     "TSFILE: /src/logic/index.d.ts",
diff --git a/src/testRunner/unittests/tsbuildWatchMode.ts b/src/testRunner/unittests/tsbuildWatchMode.ts
index 971bb39fa66..468c23c2759 100644
--- a/src/testRunner/unittests/tsbuildWatchMode.ts
+++ b/src/testRunner/unittests/tsbuildWatchMode.ts
@@ -368,6 +368,58 @@ function myFunc() { return 100; }`);
             }
         });
 
+        it("when referenced project change introduces error in the down stream project and then fixes it", () => {
+            const subProjectLibrary = `${projectsLocation}/${project}/Library`;
+            const libraryTs: File = {
+                path: `${subProjectLibrary}/library.ts`,
+                content: `
+interface SomeObject
+{
+	message: string;
+}
+
+export function createSomeObject(): SomeObject
+{
+	return {
+		message: "new Object"
+	};
+}`
+            };
+            const libraryTsconfig: File = {
+                path: `${subProjectLibrary}/tsconfig.json`,
+                content: JSON.stringify({ compilerOptions: { composite: true } })
+            };
+            const subProjectApp = `${projectsLocation}/${project}/App`;
+            const appTs: File = {
+                path: `${subProjectApp}/app.ts`,
+                content: `import { createSomeObject } from "../Library/library";
+createSomeObject().message;`
+            };
+            const appTsconfig: File = {
+                path: `${subProjectApp}/tsconfig.json`,
+                content: JSON.stringify({ references: [{ path: "../Library" }] })
+            };
+
+            const files = [libFile, libraryTs, libraryTsconfig, appTs, appTsconfig];
+            const host = createWatchedSystem(files, { currentDirectory: `${projectsLocation}/${project}` });
+            createSolutionBuilderWithWatch(host, ["App"]);
+            checkOutputErrorsInitial(host, emptyArray);
+
+            // Change message in library to message2
+            host.writeFile(libraryTs.path, libraryTs.content.replace(/message/g, "message2"));
+            host.checkTimeoutQueueLengthAndRun(1); // Build library
+            host.checkTimeoutQueueLengthAndRun(1); // Build App
+            checkOutputErrorsIncremental(host, [
+                "App/app.ts(2,20): error TS2551: Property 'message' does not exist on type 'SomeObject'. Did you mean 'message2'?\n"
+            ]);
+
+            // Revert library changes
+            host.writeFile(libraryTs.path, libraryTs.content);
+            host.checkTimeoutQueueLengthAndRun(1); // Build library
+            host.checkTimeoutQueueLengthAndRun(1); // Build App
+            checkOutputErrorsIncremental(host, emptyArray);
+        });
+
         describe("reports errors in all projects on incremental compile", () => {
             function verifyIncrementalErrors(defaultBuildOptions?: BuildOptions, disabledConsoleClear?: boolean) {
                 const host = createSolutionInWatchMode(allFiles, defaultBuildOptions, disabledConsoleClear);
diff --git a/src/testRunner/unittests/tsserverProjectSystem.ts b/src/testRunner/unittests/tsserverProjectSystem.ts
index 7ab2d09a3c1..ff3ee81b039 100644
--- a/src/testRunner/unittests/tsserverProjectSystem.ts
+++ b/src/testRunner/unittests/tsserverProjectSystem.ts
@@ -1826,6 +1826,63 @@ namespace ts.projectSystem {
             }
         });
 
+        it("file with name constructor.js doesnt cause issue with typeAcquisition when safe type list", () => {
+            const file1 = {
+                path: "/a/b/f1.js",
+                content: `export let x = 5; import { s } from "s"`
+            };
+            const constructorFile = {
+                path: "/a/b/constructor.js",
+                content: "const x = 10;"
+            };
+            const bliss = {
+                path: "/a/b/bliss.js",
+                content: "export function is() { return true; }"
+            };
+            const host = createServerHost([file1, libFile, constructorFile, bliss, customTypesMap]);
+            let request: string | undefined;
+            const cachePath = "/a/data";
+            const typingsInstaller: server.ITypingsInstaller = {
+                isKnownTypesPackageName: returnFalse,
+                installPackage: notImplemented,
+                inspectValue: notImplemented,
+                enqueueInstallTypingsRequest: (proj, typeAcquisition, unresolvedImports) => {
+                    assert.isUndefined(request);
+                    request = JSON.stringify(server.createInstallTypingsRequest(proj, typeAcquisition, unresolvedImports || server.emptyArray, cachePath));
+                },
+                attach: noop,
+                onProjectClosed: noop,
+                globalTypingsCacheLocation: cachePath
+            };
+
+            const projectName = "project";
+            const projectService = createProjectService(host, { typingsInstaller });
+            projectService.openExternalProject({ projectFileName: projectName, options: {}, rootFiles: toExternalFiles([file1.path, constructorFile.path, bliss.path]) });
+            assert.equal(request, JSON.stringify({
+                projectName,
+                fileNames: [libFile.path, file1.path, constructorFile.path, bliss.path],
+                compilerOptions: { allowNonTsExtensions: true, noEmitForJsFiles: true },
+                typeAcquisition: { include: ["blissfuljs"], exclude: [], enable: true },
+                unresolvedImports: ["s"],
+                projectRootPath: "/",
+                cachePath,
+                kind: "discover"
+            }));
+            const response = JSON.parse(request!);
+            request = undefined;
+            projectService.updateTypingsForProject({
+                kind: "action::set",
+                projectName: response.projectName,
+                typeAcquisition: response.typeAcquisition,
+                compilerOptions: response.compilerOptions,
+                typings: emptyArray,
+                unresolvedImports: response.unresolvedImports,
+            });
+
+            host.checkTimeoutQueueLengthAndRun(2);
+            assert.isUndefined(request);
+        });
+
         it("ignores files excluded by the default type list", () => {
             const file1 = {
                 path: "/a/b/f1.js",
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index b9ab9b9d986..de62251fe10 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -8498,7 +8498,7 @@ declare namespace ts.server {
         private readonly throttledOperations;
         private readonly hostConfiguration;
         private safelist;
-        private legacySafelist;
+        private readonly legacySafelist;
         private pendingProjectUpdates;
         readonly currentDirectory: NormalizedPath;
         readonly toCanonicalFileName: (f: string) => string;
diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.errors.txt b/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.errors.txt
index ce4368081f1..59280d2006a 100644
--- a/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.errors.txt
+++ b/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.errors.txt
@@ -1,24 +1,17 @@
-tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts(3,20): error TS2373: Initializer of parameter 'bar' cannot reference identifier 'foo' declared after it.
-tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts(8,27): error TS2373: Initializer of parameter 'bar' cannot reference identifier 'foo' declared after it.
 tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts(13,20): error TS2373: Initializer of parameter 'bar' cannot reference identifier 'foo' declared after it.
 tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts(21,18): error TS2372: Parameter 'a' cannot be referenced in its initializer.
 tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts(25,22): error TS2372: Parameter 'async' cannot be referenced in its initializer.
-tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts(29,15): error TS2448: Block-scoped variable 'foo' used before its declaration.
 
 
-==== tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts (6 errors) ====
+==== tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts (3 errors) ====
     let foo: string = "";
     
     function f1 (bar = foo) { // unexpected compiler error; works at runtime
-                       ~~~
-!!! error TS2373: Initializer of parameter 'bar' cannot reference identifier 'foo' declared after it.
         var foo: number = 2;
         return bar; // returns 1
     }
     
     function f2 (bar = (baz = foo) => baz) { // unexpected compiler error; works at runtime
-                              ~~~
-!!! error TS2373: Initializer of parameter 'bar' cannot reference identifier 'foo' declared after it.
         var foo: number = 2;
         return bar(); // returns 1
     }
@@ -46,9 +39,6 @@ tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.t
     }
     
     function f7({[foo]: bar}: any[]) {
-                  ~~~
-!!! error TS2448: Block-scoped variable 'foo' used before its declaration.
-!!! related TS2728 tests/cases/conformance/functions/parameterInitializersForwardReferencing1_es6.ts:30:9: 'foo' is declared here.
         let foo: number = 2;
     }
     
diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.symbols b/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.symbols
index b44c91e8afd..dcd204beb7b 100644
--- a/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.symbols
+++ b/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.symbols
@@ -5,7 +5,7 @@ let foo: string = "";
 function f1 (bar = foo) { // unexpected compiler error; works at runtime
 >f1 : Symbol(f1, Decl(parameterInitializersForwardReferencing1_es6.ts, 0, 21))
 >bar : Symbol(bar, Decl(parameterInitializersForwardReferencing1_es6.ts, 2, 13))
->foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 3, 7))
+>foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 0, 3))
 
     var foo: number = 2;
 >foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 3, 7))
@@ -18,7 +18,7 @@ function f2 (bar = (baz = foo) => baz) { // unexpected compiler error; works at
 >f2 : Symbol(f2, Decl(parameterInitializersForwardReferencing1_es6.ts, 5, 1))
 >bar : Symbol(bar, Decl(parameterInitializersForwardReferencing1_es6.ts, 7, 13))
 >baz : Symbol(baz, Decl(parameterInitializersForwardReferencing1_es6.ts, 7, 20))
->foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 8, 7))
+>foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 0, 3))
 >baz : Symbol(baz, Decl(parameterInitializersForwardReferencing1_es6.ts, 7, 20))
 
     var foo: number = 2;
@@ -68,7 +68,7 @@ function f6 (async = async) {
 
 function f7({[foo]: bar}: any[]) {
 >f7 : Symbol(f7, Decl(parameterInitializersForwardReferencing1_es6.ts, 26, 1))
->foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 29, 7))
+>foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1_es6.ts, 0, 3))
 >bar : Symbol(bar, Decl(parameterInitializersForwardReferencing1_es6.ts, 28, 13))
 
     let foo: number = 2;
diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.types b/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.types
index a58d19c5755..8fc5d84ae8e 100644
--- a/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.types
+++ b/tests/baselines/reference/parameterInitializersForwardReferencing1_es6.types
@@ -4,33 +4,33 @@ let foo: string = "";
 >"" : ""
 
 function f1 (bar = foo) { // unexpected compiler error; works at runtime
->f1 : (bar?: number) => number
->bar : number
->foo : number
+>f1 : (bar?: string) => string
+>bar : string
+>foo : string
 
     var foo: number = 2;
 >foo : number
 >2 : 2
 
     return bar; // returns 1
->bar : number
+>bar : string
 }
 
 function f2 (bar = (baz = foo) => baz) { // unexpected compiler error; works at runtime
->f2 : (bar?: (baz?: number) => number) => number
->bar : (baz?: number) => number
->(baz = foo) => baz : (baz?: number) => number
->baz : number
->foo : number
->baz : number
+>f2 : (bar?: (baz?: string) => string) => string
+>bar : (baz?: string) => string
+>(baz = foo) => baz : (baz?: string) => string
+>baz : string
+>foo : string
+>baz : string
 
     var foo: number = 2;
 >foo : number
 >2 : 2
 
     return bar(); // returns 1
->bar() : number
->bar : (baz?: number) => number
+>bar() : string
+>bar : (baz?: string) => string
 }
 
 function f3 (bar = foo, foo = 2) { // correct compiler error, error at runtime
@@ -74,7 +74,7 @@ function f6 (async = async) {
 
 function f7({[foo]: bar}: any[]) {
 >f7 : ({ [foo]: bar }: any[]) => void
->foo : number
+>foo : string
 >bar : any
 
     let foo: number = 2;
diff --git a/tests/baselines/reference/staticMismatchBecauseOfPrototype.errors.txt b/tests/baselines/reference/staticMismatchBecauseOfPrototype.errors.txt
new file mode 100644
index 00000000000..49760196800
--- /dev/null
+++ b/tests/baselines/reference/staticMismatchBecauseOfPrototype.errors.txt
@@ -0,0 +1,19 @@
+tests/cases/compiler/staticMismatchBecauseOfPrototype.ts(10,5): error TS2416: Property 'n' in type 'B' is not assignable to the same property in base type 'A'.
+  Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/compiler/staticMismatchBecauseOfPrototype.ts (1 errors) ====
+    interface A {
+        n: number;
+    }
+    declare var A: {
+        prototype: A;
+        new(): A;
+    };
+    
+    class B extends A {
+        n = "";
+        ~
+!!! error TS2416: Property 'n' in type 'B' is not assignable to the same property in base type 'A'.
+!!! error TS2416:   Type 'string' is not assignable to type 'number'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/staticMismatchBecauseOfPrototype.js b/tests/baselines/reference/staticMismatchBecauseOfPrototype.js
new file mode 100644
index 00000000000..4bc7b248957
--- /dev/null
+++ b/tests/baselines/reference/staticMismatchBecauseOfPrototype.js
@@ -0,0 +1,36 @@
+//// [staticMismatchBecauseOfPrototype.ts]
+interface A {
+    n: number;
+}
+declare var A: {
+    prototype: A;
+    new(): A;
+};
+
+class B extends A {
+    n = "";
+}
+
+//// [staticMismatchBecauseOfPrototype.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var B = /** @class */ (function (_super) {
+    __extends(B, _super);
+    function B() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.n = "";
+        return _this;
+    }
+    return B;
+}(A));
diff --git a/tests/baselines/reference/staticMismatchBecauseOfPrototype.symbols b/tests/baselines/reference/staticMismatchBecauseOfPrototype.symbols
new file mode 100644
index 00000000000..98abd4b9e1c
--- /dev/null
+++ b/tests/baselines/reference/staticMismatchBecauseOfPrototype.symbols
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/staticMismatchBecauseOfPrototype.ts ===
+interface A {
+>A : Symbol(A, Decl(staticMismatchBecauseOfPrototype.ts, 0, 0), Decl(staticMismatchBecauseOfPrototype.ts, 3, 11))
+
+    n: number;
+>n : Symbol(A.n, Decl(staticMismatchBecauseOfPrototype.ts, 0, 13))
+}
+declare var A: {
+>A : Symbol(A, Decl(staticMismatchBecauseOfPrototype.ts, 0, 0), Decl(staticMismatchBecauseOfPrototype.ts, 3, 11))
+
+    prototype: A;
+>prototype : Symbol(prototype, Decl(staticMismatchBecauseOfPrototype.ts, 3, 16))
+>A : Symbol(A, Decl(staticMismatchBecauseOfPrototype.ts, 0, 0), Decl(staticMismatchBecauseOfPrototype.ts, 3, 11))
+
+    new(): A;
+>A : Symbol(A, Decl(staticMismatchBecauseOfPrototype.ts, 0, 0), Decl(staticMismatchBecauseOfPrototype.ts, 3, 11))
+
+};
+
+class B extends A {
+>B : Symbol(B, Decl(staticMismatchBecauseOfPrototype.ts, 6, 2))
+>A : Symbol(A, Decl(staticMismatchBecauseOfPrototype.ts, 0, 0), Decl(staticMismatchBecauseOfPrototype.ts, 3, 11))
+
+    n = "";
+>n : Symbol(B.n, Decl(staticMismatchBecauseOfPrototype.ts, 8, 19))
+}
diff --git a/tests/baselines/reference/staticMismatchBecauseOfPrototype.types b/tests/baselines/reference/staticMismatchBecauseOfPrototype.types
new file mode 100644
index 00000000000..d55c86b3fc7
--- /dev/null
+++ b/tests/baselines/reference/staticMismatchBecauseOfPrototype.types
@@ -0,0 +1,22 @@
+=== tests/cases/compiler/staticMismatchBecauseOfPrototype.ts ===
+interface A {
+    n: number;
+>n : number
+}
+declare var A: {
+>A : { new (): A; prototype: A; }
+
+    prototype: A;
+>prototype : A
+
+    new(): A;
+};
+
+class B extends A {
+>B : B
+>A : A
+
+    n = "";
+>n : string
+>"" : ""
+}
diff --git a/tests/baselines/reference/user/enhanced-resolve.log b/tests/baselines/reference/user/enhanced-resolve.log
index 24d0c3b9839..7dd284bf166 100644
--- a/tests/baselines/reference/user/enhanced-resolve.log
+++ b/tests/baselines/reference/user/enhanced-resolve.log
@@ -1,10 +1,10 @@
 Exit Code: 1
 Standard output:
-node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(116,18): error TS2345: Argument of type 'Timer | null' is not assignable to parameter of type 'number | undefined'.
+node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(116,18): error TS2345: Argument of type 'Timeout | null' is not assignable to parameter of type 'number | undefined'.
   Type 'null' is not assignable to type 'number | undefined'.
-node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(129,18): error TS2345: Argument of type 'Timer | null' is not assignable to parameter of type 'number | undefined'.
+node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(129,18): error TS2345: Argument of type 'Timeout | null' is not assignable to parameter of type 'number | undefined'.
   Type 'null' is not assignable to type 'number | undefined'.
-node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(147,18): error TS2345: Argument of type 'Timer | null' is not assignable to parameter of type 'number | undefined'.
+node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(147,18): error TS2345: Argument of type 'Timeout | null' is not assignable to parameter of type 'number | undefined'.
   Type 'null' is not assignable to type 'number | undefined'.
 node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(176,19): error TS2322: Type 'null' is not assignable to type '(path: any, callback: any) => void'.
 node_modules/enhanced-resolve/lib/CachedInputFileSystem.js(179,23): error TS2322: Type 'null' is not assignable to type '(path: any) => any'.
diff --git a/tests/baselines/reference/user/npm.log b/tests/baselines/reference/user/npm.log
index 1caa051e2de..435d962fa95 100644
--- a/tests/baselines/reference/user/npm.log
+++ b/tests/baselines/reference/user/npm.log
@@ -919,6 +919,8 @@ node_modules/npm/test/broken-under-nyc-and-travis/whoami.js(7,20): error TS2307:
 node_modules/npm/test/common-tap.js(5,47): error TS2339: Property '_extend' does not exist on type 'typeof import("util")'.
 node_modules/npm/test/common-tap.js(10,3): error TS2322: Type '(...args: any[]) => void' is not assignable to type 'typeof setImmediate'.
   Property '__promisify__' is missing in type '(...args: any[]) => void'.
+node_modules/npm/test/common-tap.js(10,36): error TS2322: Type '(...args: any[]) => void' is not assignable to type '(callback: (...args: any[]) => void, ...args: any[]) => Immediate'.
+  Type 'void' is not assignable to type 'Immediate'.
 node_modules/npm/test/common-tap.js(12,28): error TS2345: Argument of type 'any[]' is not assignable to parameter of type '[(...args: any[]) => void, number, ...any[]]'.
   Property '0' is missing in type 'any[]'.
 node_modules/npm/test/common-tap.js(175,17): error TS2339: Property '_storage' does not exist on type 'Environment'.
diff --git a/tests/cases/compiler/staticMismatchBecauseOfPrototype.ts b/tests/cases/compiler/staticMismatchBecauseOfPrototype.ts
new file mode 100644
index 00000000000..24d50f1951d
--- /dev/null
+++ b/tests/cases/compiler/staticMismatchBecauseOfPrototype.ts
@@ -0,0 +1,11 @@
+interface A {
+    n: number;
+}
+declare var A: {
+    prototype: A;
+    new(): A;
+};
+
+class B extends A {
+    n = "";
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/importNameCodeFix_defaultExport.ts b/tests/cases/fourslash/importNameCodeFix_defaultExport.ts
new file mode 100644
index 00000000000..fa8cef71c99
--- /dev/null
+++ b/tests/cases/fourslash/importNameCodeFix_defaultExport.ts
@@ -0,0 +1,18 @@
+/// <reference path="fourslash.ts" />
+
+// @allowJs: true
+// @checkJs: true
+
+// @Filename: /a.js
+////class C {}
+////export default C;
+
+// @Filename: /b.js
+////[|C;|]
+
+goTo.file("/b.js");
+verify.importFixAtPosition([
+`import C from "./a";
+
+C;`,
+]);