typescript 4.7.0-dev.20220505 → 4.7.0-dev.20220506

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220505";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220506";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8398,6 +8398,8 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
+        The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -18223,6 +18225,16 @@ var ts;
                     ".d.ts" /* Dts */;
     }
     ts.getDeclarationEmitExtensionForPath = getDeclarationEmitExtensionForPath;
+    /**
+     * This function is an inverse of `getDeclarationEmitExtensionForPath`.
+     */
+    function getPossibleOriginalInputExtensionForExtension(path) {
+        return ts.fileExtensionIsOneOf(path, [".d.mts" /* Dmts */, ".mjs" /* Mjs */, ".mts" /* Mts */]) ? [".mts" /* Mts */, ".mjs" /* Mjs */] :
+            ts.fileExtensionIsOneOf(path, [".d.cts" /* Dcts */, ".cjs" /* Cjs */, ".cts" /* Cts */]) ? [".cts" /* Cts */, ".cjs" /* Cjs */] :
+                ts.fileExtensionIsOneOf(path, [".json.d.ts"]) ? [".json" /* Json */] :
+                    [".tsx" /* Tsx */, ".ts" /* Ts */, ".jsx" /* Jsx */, ".js" /* Js */];
+    }
+    ts.getPossibleOriginalInputExtensionForExtension = getPossibleOriginalInputExtensionForExtension;
     function outFile(options) {
         return options.outFile || options.out;
     }
@@ -38944,6 +38956,7 @@ var ts;
         ["es2021.intl", "lib.es2021.intl.d.ts"],
         ["es2022.array", "lib.es2022.array.d.ts"],
         ["es2022.error", "lib.es2022.error.d.ts"],
+        ["es2022.intl", "lib.es2022.intl.d.ts"],
         ["es2022.object", "lib.es2022.object.d.ts"],
         ["es2022.string", "lib.es2022.string.d.ts"],
         ["esnext.array", "lib.es2022.array.d.ts"],
@@ -42142,7 +42155,7 @@ var ts;
         ts.Debug.assert(ts.extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
     }
-    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, resultFromCache) {
+    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, diagnostics, resultFromCache) {
         var _a;
         if (resultFromCache) {
             (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
@@ -42150,7 +42163,8 @@ var ts;
         }
         return {
             resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
-            failedLookupLocations: failedLookupLocations
+            failedLookupLocations: failedLookupLocations,
+            resolutionDiagnostics: diagnostics
         };
     }
     function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
@@ -42351,7 +42365,18 @@ var ts;
             features |= NodeResolutionFeatures.EsmMode;
         }
         var conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : [];
-        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: conditions };
+        var diagnostics = [];
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: traceEnabled,
+            failedLookupLocations: failedLookupLocations,
+            packageJsonInfoCache: cache,
+            features: features,
+            conditions: conditions,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+        };
         var resolved = primaryLookup();
         var primary = true;
         if (!resolved) {
@@ -42370,7 +42395,7 @@ var ts;
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
         }
-        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
+        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, resolutionDiagnostics: diagnostics };
         perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);
         if (traceEnabled)
             traceResult(result);
@@ -42453,6 +42478,8 @@ var ts;
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ts.emptyArray,
             features: NodeResolutionFeatures.None,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: ts.noop
         };
         return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
@@ -43104,6 +43131,7 @@ var ts;
         if (compilerOptions.noDtsResolution) {
             conditions.pop();
         }
+        var diagnostics = [];
         var state = {
             compilerOptions: compilerOptions,
             host: host,
@@ -43112,9 +43140,11 @@ var ts;
             packageJsonInfoCache: cache,
             features: features,
             conditions: conditions,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
-        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ true); };
             var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
@@ -43287,9 +43317,9 @@ var ts;
         }
     }
     function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
-        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.isDeclarationFileName(candidate)) {
+        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.fileExtensionIsOneOf(candidate, ts.supportedTSExtensionsFlat)) {
             var result = tryFile(candidate, onlyRecordFailures, state);
-            return result !== undefined ? { path: candidate, ext: ts.forEach(ts.supportedDeclarationExtensions, function (e) { return ts.fileExtensionIs(candidate, e) ? e : undefined; }) } : undefined;
+            return result !== undefined ? { path: candidate, ext: ts.tryExtractTSExtension(candidate) } : undefined;
         }
         return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
     }
@@ -43412,6 +43442,8 @@ var ts;
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ["node", "require", "types"],
             features: features,
+            requestContainingDirectory: packageJsonInfo.packageDirectory,
+            reportDiagnostic: ts.noop
         };
         var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, 
         /*onlyRecordFailures*/ false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
@@ -43498,6 +43530,8 @@ var ts;
             packageJsonInfoCache: packageJsonInfoCache,
             features: 0,
             conditions: [],
+            requestContainingDirectory: undefined,
+            reportDiagnostic: ts.noop
         };
         var parts = ts.getPathComponents(fileName);
         parts.pop();
@@ -43789,7 +43823,6 @@ var ts;
     function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
         return loadModuleFromTargetImportOrExport;
         function loadModuleFromTargetImportOrExport(target, subpath, pattern) {
-            var _a, _b;
             if (typeof target === "string") {
                 if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) {
                     if (state.traceEnabled) {
@@ -43826,13 +43859,16 @@ var ts;
                     }
                     return toSearchResult(/*value*/ undefined);
                 }
-                var finalPath = ts.getNormalizedAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                var finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
+                var inputLink = tryLoadInputFileForPath(finalPath, subpath, ts.combinePaths(scope.packageDirectory, "package.json"), isImports);
+                if (inputLink)
+                    return inputLink;
                 return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, /*onlyRecordFailures*/ false, state)));
             }
             else if (typeof target === "object" && target !== null) { // eslint-disable-line no-null/no-null
                 if (!Array.isArray(target)) {
-                    for (var _i = 0, _c = ts.getOwnKeys(target); _i < _c.length; _i++) {
-                        var key = _c[_i];
+                    for (var _i = 0, _a = ts.getOwnKeys(target); _i < _a.length; _i++) {
+                        var key = _a[_i];
                         if (key === "default" || state.conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(state.conditions, key)) {
                             var subTarget = target[key];
                             var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern);
@@ -43850,8 +43886,8 @@ var ts;
                         }
                         return toSearchResult(/*value*/ undefined);
                     }
-                    for (var _d = 0, target_2 = target; _d < target_2.length; _d++) {
-                        var elem = target_2[_d];
+                    for (var _b = 0, target_2 = target; _b < target_2.length; _b++) {
+                        var elem = target_2[_b];
                         var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
                         if (result) {
                             return result;
@@ -43869,6 +43905,128 @@ var ts;
                 trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
             }
             return toSearchResult(/*value*/ undefined);
+            function toAbsolutePath(path) {
+                var _a, _b;
+                if (path === undefined)
+                    return path;
+                return ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames })(ts.getNormalizedAbsolutePath(path, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)));
+            }
+            function combineDirectoryPath(root, dir) {
+                return ts.ensureTrailingDirectorySeparator(ts.combinePaths(root, dir));
+            }
+            function useCaseSensitiveFileNames() {
+                return !state.host.useCaseSensitiveFileNames ? true :
+                    typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames :
+                        state.host.useCaseSensitiveFileNames();
+            }
+            function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports) {
+                var _a, _b, _c, _d;
+                // Replace any references to outputs for files in the program with the input files to support package self-names used with outDir
+                // PROBLEM: We don't know how to calculate the output paths yet, because the "common source directory" we use as the base of the file structure
+                // we reproduce into the output directory is based on the set of input files, which we're still in the process of traversing and resolving!
+                // _Given that_, we have to guess what the base of the output directory is (obviously the user wrote the export map, so has some idea what it is!).
+                // We are going to probe _so many_ possible paths. We limit where we'll do this to try to reduce the possibilities of false positive lookups.
+                if ((extensions === Extensions.TypeScript || extensions === Extensions.JavaScript || extensions === Extensions.Json)
+                    && (state.compilerOptions.declarationDir || state.compilerOptions.outDir)
+                    && finalPath.indexOf("/node_modules/") === -1
+                    && (state.compilerOptions.configFile ? ts.startsWith(toAbsolutePath(state.compilerOptions.configFile.fileName), scope.packageDirectory) : true)) {
+                    // So that all means we'll only try these guesses for files outside `node_modules` in a directory where the `package.json` and `tsconfig.json` are siblings.
+                    // Even with all that, we still don't know if the root of the output file structure will be (relative to the package file)
+                    // `.`, `./src` or any other deeper directory structure. (If project references are used, it's definitely `.` by fiat, so that should be pretty common.)
+                    var getCanonicalFileName = ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames });
+                    var commonSourceDirGuesses = [];
+                    // A `rootDir` compiler option strongly indicates the root location
+                    // A `composite` project is using project references and has it's common src dir set to `.`, so it shouldn't need to check any other locations
+                    if (state.compilerOptions.rootDir || (state.compilerOptions.composite && state.compilerOptions.configFilePath)) {
+                        var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return []; }, ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "", getCanonicalFileName));
+                        commonSourceDirGuesses.push(commonDir);
+                    }
+                    else if (state.requestContainingDirectory) {
+                        // However without either of those set we're in the dark. Let's say you have
+                        //
+                        // ./tools/index.ts
+                        // ./src/index.ts
+                        // ./dist/index.js
+                        // ./package.json <-- references ./dist/index.js
+                        // ./tsconfig.json <-- loads ./src/index.ts
+                        //
+                        // How do we know `./src` is the common src dir, and not `./tools`, given only the `./dist` out dir and `./dist/index.js` filename?
+                        // Answer: We... don't. We know we're looking for an `index.ts` input file, but we have _no clue_ which subfolder it's supposed to be loaded from
+                        // without more context.
+                        // But we do have more context! Just a tiny bit more! We're resolving an import _for some other input file_! And that input file, too
+                        // must be inside the common source directory! So we propagate that tidbit of info all the way to here via state.requestContainingDirectory
+                        var requestingFile_1 = toAbsolutePath(ts.combinePaths(state.requestContainingDirectory, "index.ts"));
+                        // And we can try every folder above the common folder for the request folder and the config/package base directory
+                        // This technically can be wrong - we may load ./src/index.ts when ./src/sub/index.ts was right because we don't
+                        // know if only `./src/sub` files were loaded by the program; but this has the best chance to be right of just about anything
+                        // else we have. And, given that we're about to load `./src/index.ts` because we choose it as likely correct, there will then
+                        // be a file outside of `./src/sub` in the program (the file we resolved to), making us de-facto right. So this fallback lookup
+                        // logic may influence what files are pulled in by self-names, which in turn influences the output path shape, but it's all
+                        // internally consistent so the paths should be stable so long as we prefer the "most general" (meaning: top-most-level directory) possible results first.
+                        var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return [requestingFile_1, toAbsolutePath(packagePath)]; }, ((_d = (_c = state.host).getCurrentDirectory) === null || _d === void 0 ? void 0 : _d.call(_c)) || "", getCanonicalFileName));
+                        commonSourceDirGuesses.push(commonDir);
+                        var fragment = ts.ensureTrailingDirectorySeparator(commonDir);
+                        while (fragment && fragment.length > 1) {
+                            var parts = ts.getPathComponents(fragment);
+                            parts.pop(); // remove a directory
+                            var commonDir_1 = ts.getPathFromPathComponents(parts);
+                            commonSourceDirGuesses.unshift(commonDir_1);
+                            fragment = ts.ensureTrailingDirectorySeparator(commonDir_1);
+                        }
+                    }
+                    if (commonSourceDirGuesses.length > 1) {
+                        state.reportDiagnostic(ts.createCompilerDiagnostic(isImports
+                            ? ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate
+                            : ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, entry === "" ? "." : entry, // replace empty string with `.` - the reverse of the operation done when entries are built - so main entrypoint errors don't look weird
+                        packagePath));
+                    }
+                    for (var _i = 0, commonSourceDirGuesses_1 = commonSourceDirGuesses; _i < commonSourceDirGuesses_1.length; _i++) {
+                        var commonSourceDirGuess = commonSourceDirGuesses_1[_i];
+                        var candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
+                        for (var _e = 0, candidateDirectories_1 = candidateDirectories; _e < candidateDirectories_1.length; _e++) {
+                            var candidateDir = candidateDirectories_1[_e];
+                            if (ts.startsWith(finalPath, candidateDir)) {
+                                // The matched export is looking up something in either the out declaration or js dir, now map the written path back into the source dir and source extension
+                                var pathFragment = finalPath.slice(candidateDir.length + 1); // +1 to also remove directory seperator
+                                var possibleInputBase = ts.combinePaths(commonSourceDirGuess, pathFragment);
+                                var jsAndDtsExtensions = [".mjs" /* Mjs */, ".cjs" /* Cjs */, ".js" /* Js */, ".json" /* Json */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".d.ts" /* Dts */];
+                                for (var _f = 0, jsAndDtsExtensions_1 = jsAndDtsExtensions; _f < jsAndDtsExtensions_1.length; _f++) {
+                                    var ext = jsAndDtsExtensions_1[_f];
+                                    if (ts.fileExtensionIs(possibleInputBase, ext)) {
+                                        var inputExts = ts.getPossibleOriginalInputExtensionForExtension(possibleInputBase);
+                                        for (var _g = 0, inputExts_1 = inputExts; _g < inputExts_1.length; _g++) {
+                                            var possibleExt = inputExts_1[_g];
+                                            var possibleInputWithInputExtension = ts.changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
+                                            if ((extensions === Extensions.TypeScript && ts.hasJSFileExtension(possibleInputWithInputExtension)) ||
+                                                (extensions === Extensions.JavaScript && ts.hasTSFileExtension(possibleInputWithInputExtension))) {
+                                                continue;
+                                            }
+                                            if (state.host.fileExists(possibleInputWithInputExtension)) {
+                                                return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, /*onlyRecordFailures*/ false, state)));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return undefined;
+                function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) {
+                    var _a, _b;
+                    // Config file ouput paths are processed to be relative to the host's current directory, while
+                    // otherwise the paths are resolved relative to the common source dir the compiler puts together
+                    var currentDir = state.compilerOptions.configFile ? ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "" : commonSourceDirGuess;
+                    var candidateDirectories = [];
+                    if (state.compilerOptions.declarationDir) {
+                        candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.declarationDir)));
+                    }
+                    if (state.compilerOptions.outDir && state.compilerOptions.outDir !== state.compilerOptions.declarationDir) {
+                        candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.outDir)));
+                    }
+                    return candidateDirectories;
+                }
+            }
         }
     }
     /* @internal */
@@ -44059,11 +44217,12 @@ var ts;
     function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [] };
         var containingDirectory = ts.getDirectoryPath(containingFile);
+        var diagnostics = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: containingDirectory, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
         // No originalPath because classic resolution doesn't resolve realPath
-        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
             if (resolvedUsingSettings) {
@@ -44106,9 +44265,10 @@ var ts;
             trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
         }
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [] };
+        var diagnostics = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: undefined, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
         var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined);
-        return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations, diagnostics, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
     /**
@@ -57972,7 +58132,8 @@ var ts;
                 if (symbol === globalThisSymbol) {
                     var varsOnly_1 = new ts.Map();
                     members.forEach(function (p) {
-                        if (!(p.flags & 418 /* BlockScoped */)) {
+                        var _a;
+                        if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a = p.declarations) === null || _a === void 0 ? void 0 : _a.length) && ts.every(p.declarations, ts.isAmbientModule))) {
                             varsOnly_1.set(p.escapedName, p);
                         }
                     });
@@ -86163,7 +86324,7 @@ var ts;
             if (ts.isDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
                 var symbol = getSymbolOfNode(node);
-                return getTypeOfSymbol(symbol);
+                return symbol ? getTypeOfSymbol(symbol) : errorType;
             }
             if (isDeclarationNameOrImportPropertyName(node)) {
                 var symbol = getSymbolAtLocation(node);
@@ -116077,7 +116238,6 @@ var ts;
         ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer.code,
         ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code,
         ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code,
-        ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body.code,
         ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
         ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
         ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
@@ -116464,6 +116624,40 @@ var ts;
         ts.performance.measure("Program", "beforeProgram", "afterProgram");
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return program;
+        function addResolutionDiagnostics(list) {
+            if (!list)
+                return;
+            for (var _i = 0, list_3 = list; _i < list_3.length; _i++) {
+                var elem = list_3[_i];
+                programDiagnostics.add(elem);
+            }
+        }
+        function pullDiagnosticsFromCache(names, containingFile) {
+            var _a;
+            if (!moduleResolutionCache)
+                return;
+            var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
+            var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
+            var containingDir = ts.getDirectoryPath(containingFileName);
+            var redirectedReference = getRedirectReferenceForResolution(containingFile);
+            var i = 0;
+            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
+                var n = names_4[_i];
+                // mimics logic done in the resolution cache, should be resilient to upgrading it to use `FileReference`s for non-type-reference modal lookups to make it rely on the index in the list less
+                var mode = typeof n === "string" ? getModeForResolutionAtIndex(containingFile, i) : getModeForFileReference(n, containingFileMode);
+                var name = typeof n === "string" ? n : n.fileName;
+                i++;
+                // only nonrelative names hit the cache, and, at least as of right now, only nonrelative names can issue diagnostics
+                // (Since diagnostics are only issued via import or export map lookup)
+                // This may totally change if/when the issue of output paths not mapping to input files is fixed in a broader context
+                // When it is, how we extract diagnostics from the module name resolver will have the be refined - the current cache
+                // APIs wrapping the underlying resolver make it almost impossible to smuggle the diagnostics out in a generalized way
+                if (ts.isExternalModuleNameRelative(name))
+                    continue;
+                var diags = (_a = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) === null || _a === void 0 ? void 0 : _a.resolutionDiagnostics;
+                addResolutionDiagnostics(diags);
+            }
+        }
         function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
             if (!moduleNames.length)
                 return ts.emptyArray;
@@ -116475,6 +116669,7 @@ var ts;
             ts.performance.mark("afterResolveModule");
             ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
+            pullDiagnosticsFromCache(moduleNames, containingFile);
             return result;
         }
         function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) {
@@ -120911,8 +121106,8 @@ var ts;
                 !!redirectedReference;
             var seenNamesInFile = ts.createModeAwareCache();
             var i = 0;
-            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
-                var entry = names_4[_i];
+            for (var _i = 0, names_5 = names; _i < names_5.length; _i++) {
+                var entry = names_5[_i];
                 var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase();
                 // Imports supply a `containingSourceFile` but no `containingSourceFileMode` - it would be redundant
                 // they require calculating the mode for a given import from it's position in the resolution table, since a given

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.7.0-dev.20220505",
+    "version": "4.7.0-dev.20220506",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [