From 9bcb0a9402e519cbb6ef508714f9b0aae101179c Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 12 Sep 2023 14:15:06 -0700 Subject: [PATCH 1/9] Support resolution-mode overrides in type-only constructs in all moduleResolution modes --- src/compiler/checker.ts | 6 -- src/compiler/diagnosticMessages.json | 4 - src/compiler/moduleNameResolver.ts | 73 +++++++++++++------ src/compiler/program.ts | 11 +-- ...ortType1(moduleresolution=bundler).symbols | 36 +++++++++ ...mportType1(moduleresolution=bundler).types | 37 ++++++++++ ...Type1(moduleresolution=classic).errors.txt | 46 ++++++++++++ ...ortType1(moduleresolution=classic).symbols | 33 +++++++++ ...mportType1(moduleresolution=classic).types | 37 ++++++++++ ...tType1(moduleresolution=node10).errors.txt | 40 ++++++++++ ...portType1(moduleresolution=node10).symbols | 35 +++++++++ ...ImportType1(moduleresolution=node10).types | 37 ++++++++++ .../resolutionModeTripleSlash1.errors.txt | 45 ++++++++++++ .../resolutionModeTripleSlash2.errors.txt | 45 ++++++++++++ .../reference/resolutionModeTripleSlash2.js | 35 +++++++++ .../resolutionModeTripleSlash3.errors.txt | 45 ++++++++++++ .../resolutionModeTripleSlash4.errors.txt | 51 +++++++++++++ .../resolutionModeTripleSlash5.errors.txt | 45 ++++++++++++ ...peOnlyImport1(moduleresolution=bundler).js | 44 +++++++++++ ...yImport1(moduleresolution=bundler).symbols | 56 ++++++++++++++ ...nlyImport1(moduleresolution=bundler).types | 57 +++++++++++++++ ...port1(moduleresolution=classic).errors.txt | 52 +++++++++++++ ...peOnlyImport1(moduleresolution=classic).js | 44 +++++++++++ ...yImport1(moduleresolution=classic).symbols | 53 ++++++++++++++ ...nlyImport1(moduleresolution=classic).types | 57 +++++++++++++++ ...mport1(moduleresolution=node10).errors.txt | 46 ++++++++++++ ...ypeOnlyImport1(moduleresolution=node10).js | 44 +++++++++++ ...lyImport1(moduleresolution=node10).symbols | 55 ++++++++++++++ ...OnlyImport1(moduleresolution=node10).types | 57 +++++++++++++++ .../resolutionModeImportType1.ts | 32 ++++++++ .../resolutionModeTripleSlash1.ts | 40 ++++++++++ .../resolutionModeTripleSlash2.ts | 41 +++++++++++ .../resolutionModeTripleSlash3.ts | 40 ++++++++++ .../resolutionModeTripleSlash4.ts | 40 ++++++++++ .../resolutionModeTripleSlash5.ts | 40 ++++++++++ .../resolutionModeTypeOnlyImport1.ts | 39 ++++++++++ 36 files changed, 1456 insertions(+), 42 deletions(-) create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).symbols create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).types create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).errors.txt create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).symbols create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).types create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).errors.txt create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).symbols create mode 100644 tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).types create mode 100644 tests/baselines/reference/resolutionModeTripleSlash1.errors.txt create mode 100644 tests/baselines/reference/resolutionModeTripleSlash2.errors.txt create mode 100644 tests/baselines/reference/resolutionModeTripleSlash2.js create mode 100644 tests/baselines/reference/resolutionModeTripleSlash3.errors.txt create mode 100644 tests/baselines/reference/resolutionModeTripleSlash4.errors.txt create mode 100644 tests/baselines/reference/resolutionModeTripleSlash5.errors.txt create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols create mode 100644 tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeTripleSlash1.ts create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeTripleSlash3.ts create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeTripleSlash4.ts create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeTripleSlash5.ts create mode 100644 tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index af0df131e9c2d..6a223c69ed639 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -39662,9 +39662,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (!isNightly()) { grammarErrorOnNode(node.assertions.assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next); } - if (getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.Node16 && getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.NodeNext) { - grammarErrorOnNode(node.assertions.assertClause, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext); - } } } @@ -45104,9 +45101,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next); } - if (getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.Node16 && getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.NodeNext) { - return grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext); - } return; // Other grammar checks do not apply to type-only imports with resolution mode assertions } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index c3c8a58d8f525..08d98c172e842 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1480,10 +1480,6 @@ "category": "Error", "code": 1451 }, - "'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`.": { - "category": "Error", - "code": 1452 - }, "`resolution-mode` should be either `require` or `import`.": { "category": "Error", "code": 1453 diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index 43e34558c7c8d..cc2eb0f90131a 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -308,6 +308,7 @@ export interface ModuleResolutionState { reportDiagnostic: DiagnosticReporter; isConfigLookup: boolean; candidateIsFromPackageJsonField: boolean; + overrideResolutionMode: ResolutionMode; } /** Just the fields that we use for module resolution. @@ -558,18 +559,21 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string const failedLookupLocations: string[] = []; const affectingLocations: string[] = []; + // Allow type reference directives to opt into `exports` resolution in any resolution mode + // when a `resolution-mode` override is present. let features = getNodeResolutionFeatures(options); - // Unlike `import` statements, whose mode-calculating APIs are all guaranteed to return `undefined` if we're in an un-mode-ed module resolution - // setting, type references will return their target mode regardless of options because of how the parser works, so we guard against the mode being - // set in a non-modal module resolution setting here. Do note that our behavior is not particularly well defined when these mode-overriding imports - // are present in a non-modal project; while in theory we'd like to either ignore the mode or provide faithful modern resolution, depending on what we feel is best, - // in practice, not every cache has the options available to intelligently make the choice to ignore the mode request, and it's unclear how modern "faithful modern - // resolution" should be (`node16`? `nodenext`?). As such, witnessing a mode-overriding triple-slash reference in a non-modal module resolution - // context should _probably_ be an error - and that should likely be handled by the `Program` (which is what we do). - if (resolutionMode === ModuleKind.ESNext && (getEmitModuleResolutionKind(options) === ModuleResolutionKind.Node16 || getEmitModuleResolutionKind(options) === ModuleResolutionKind.NodeNext)) { + if (resolutionMode !== undefined) { + features |= NodeResolutionFeatures.ResolutionModeAttributeFeatures; + } + const moduleResolution = getEmitModuleResolutionKind(options); + if (resolutionMode === ModuleKind.ESNext && (ModuleResolutionKind.Node16 <= moduleResolution && moduleResolution <= ModuleResolutionKind.NodeNext)) { features |= NodeResolutionFeatures.EsmMode; } - const conditions = features & NodeResolutionFeatures.Exports ? getConditions(options, !!(features & NodeResolutionFeatures.EsmMode)) : []; + // true: "import" / false: "require" / undefined: default based on settings + const useImportCondition = resolutionMode === ModuleKind.ESNext || (resolutionMode !== undefined ? false : undefined); + const conditions = (features & NodeResolutionFeatures.Exports) + ? getConditions(options, useImportCondition) + : []; const diagnostics: Diagnostic[] = []; const moduleResolutionState: ModuleResolutionState = { compilerOptions: options, @@ -584,6 +588,7 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup: false, candidateIsFromPackageJsonField: false, + overrideResolutionMode: resolutionMode, }; let resolved = primaryLookup(); let primary = true; @@ -728,7 +733,7 @@ function getNodeResolutionFeatures(options: CompilerOptions) { export function getConditions(options: CompilerOptions, esmMode?: boolean) { // conditions are only used by the node16/nodenext/bundler resolvers - there's no priority order in the list, // it's essentially a set (priority is determined by object insertion order in the object we look at). - const conditions = esmMode || getEmitModuleResolutionKind(options) === ModuleResolutionKind.Bundler + const conditions = esmMode || (esmMode !== false && getEmitModuleResolutionKind(options) === ModuleResolutionKind.Bundler) ? ["import"] : ["require"]; if (!options.noDtsResolution) { @@ -1411,13 +1416,13 @@ export function resolveModuleName(moduleName: string, containingFile: string, co result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); break; case ModuleResolutionKind.Node10: - result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); + result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); break; case ModuleResolutionKind.Classic: result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); break; case ModuleResolutionKind.Bundler: - result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); + result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); break; default: return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`); @@ -1670,6 +1675,10 @@ export enum NodeResolutionFeatures { BundlerDefault = Imports | SelfName | Exports | ExportsPatternTrailers, + // features required to resolve `resolution-mode` overrides in + // type reference directives, import() types, and type-only imports + ResolutionModeAttributeFeatures = Imports | SelfName | Exports | ExportsPatternTrailers, + EsmMode = 1 << 5, } @@ -1708,7 +1717,7 @@ function nodeNextModuleNameResolverWorker(features: NodeResolutionFeatures, modu if (getResolveJsonModule(compilerOptions)) { extensions |= Extensions.Json; } - return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference); + return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, /*overrideResolutionMode*/ undefined); } function tryResolveJSModuleWorker(moduleName: string, initialDir: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { @@ -1722,21 +1731,22 @@ function tryResolveJSModuleWorker(moduleName: string, initialDir: string, host: Extensions.JavaScript, /*isConfigLookup*/ false, /*redirectedReference*/ undefined, + /*overrideResolutionMode*/ undefined, ); } -export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations { +export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations { const containingDirectory = getDirectoryPath(containingFile); let extensions = compilerOptions.noDtsResolution ? Extensions.ImplementationFiles : Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration; if (getResolveJsonModule(compilerOptions)) { extensions |= Extensions.Json; } - return nodeModuleNameResolverWorker(getNodeResolutionFeatures(compilerOptions), moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference); + return nodeModuleNameResolverWorker(getNodeResolutionFeatures(compilerOptions), moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, resolutionMode); } export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; -/** @internal */ export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, lookupConfig?: boolean): ResolvedModuleWithFailedLookupLocations; // eslint-disable-line @typescript-eslint/unified-signatures -export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, isConfigLookup?: boolean): ResolvedModuleWithFailedLookupLocations { +/** @internal */ export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode, lookupConfig?: boolean): ResolvedModuleWithFailedLookupLocations; // eslint-disable-line @typescript-eslint/unified-signatures +export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode, isConfigLookup?: boolean): ResolvedModuleWithFailedLookupLocations { let extensions; if (isConfigLookup) { extensions = Extensions.Json; @@ -1750,20 +1760,35 @@ export function nodeModuleNameResolver(moduleName: string, containingFile: strin ? Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration | Extensions.Json : Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration; } - return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference); + return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference, resolutionMode); } /** @internal */ export function nodeNextJsonConfigResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - return nodeModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, getDirectoryPath(containingFile), { moduleResolution: ModuleResolutionKind.NodeNext }, host, /*cache*/ undefined, Extensions.Json, /*isConfigLookup*/ true, /*redirectedReference*/ undefined); + return nodeModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, getDirectoryPath(containingFile), { moduleResolution: ModuleResolutionKind.NodeNext }, host, /*cache*/ undefined, Extensions.Json, /*isConfigLookup*/ true, /*redirectedReference*/ undefined, /*overrideResolutionMode*/ undefined); } -function nodeModuleNameResolverWorker(features: NodeResolutionFeatures, moduleName: string, containingDirectory: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache: ModuleResolutionCache | undefined, extensions: Extensions, isConfigLookup: boolean, redirectedReference: ResolvedProjectReference | undefined): ResolvedModuleWithFailedLookupLocations { +function nodeModuleNameResolverWorker( + features: NodeResolutionFeatures, + moduleName: string, + containingDirectory: string, + compilerOptions: CompilerOptions, + host: ModuleResolutionHost, + cache: ModuleResolutionCache | undefined, + extensions: Extensions, + isConfigLookup: boolean, + redirectedReference: ResolvedProjectReference | undefined, + overrideResolutionMode: ResolutionMode, +): ResolvedModuleWithFailedLookupLocations { const traceEnabled = isTraceEnabled(compilerOptions, host); const failedLookupLocations: string[] = []; const affectingLocations: string[] = []; - const conditions = getConditions(compilerOptions, !!(features & NodeResolutionFeatures.EsmMode)); + if (overrideResolutionMode) { + features |= NodeResolutionFeatures.ResolutionModeAttributeFeatures; + } + const useImportCondition = !!(features & NodeResolutionFeatures.EsmMode) || (overrideResolutionMode ? overrideResolutionMode === ModuleKind.ESNext : undefined); + const conditions = getConditions(compilerOptions, useImportCondition); const diagnostics: Diagnostic[] = []; const state: ModuleResolutionState = { @@ -1779,6 +1804,7 @@ function nodeModuleNameResolverWorker(features: NodeResolutionFeatures, moduleNa reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup, candidateIsFromPackageJsonField: false, + overrideResolutionMode, }; if (traceEnabled && moduleResolutionSupportsPackageJsonExportsAndImports(getEmitModuleResolutionKind(compilerOptions))) { @@ -2288,6 +2314,7 @@ export function getTemporaryModuleResolutionState(packageJsonInfoCache: PackageJ reportDiagnostic: noop, isConfigLookup: false, candidateIsFromPackageJsonField: false, + overrideResolutionMode: undefined, }; } @@ -2657,7 +2684,7 @@ function getLoadModuleFromTargetImportOrExport(extensions: Extensions, state: Mo const combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath; traceIfEnabled(state, Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup); traceIfEnabled(state, Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/"); - const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, /*isConfigLookup*/ false, redirectedReference); + const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, state.overrideResolutionMode); return toSearchResult( result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, @@ -3140,6 +3167,7 @@ export function classicNameResolver(moduleName: string, containingFile: string, reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup: false, candidateIsFromPackageJsonField: false, + overrideResolutionMode: undefined, }; const resolved = tryResolve(Extensions.TypeScript | Extensions.Declaration) || @@ -3239,6 +3267,7 @@ export function loadModuleFromGlobalCache(moduleName: string, projectName: strin reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup: false, candidateIsFromPackageJsonField: false, + overrideResolutionMode: undefined, }; const resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.Declaration, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined); return createResolvedModuleWithFailedLookupLocations( diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 13a3c37bc4126..b9f292fef09d7 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -863,7 +863,6 @@ export function getModeForResolutionAtIndex(file: SourceFile, index: number): Re // eslint-disable-next-line @typescript-eslint/unified-signatures export function getModeForResolutionAtIndex(file: SourceFileImportsList, index: number): ResolutionMode; export function getModeForResolutionAtIndex(file: SourceFileImportsList, index: number): ResolutionMode { - if (file.impliedNodeFormat === undefined) return undefined; // we ensure all elements of file.imports and file.moduleAugmentations have the relevant parent pointers set during program setup, // so it's safe to use them even pre-bind return getModeForUsageLocation(file, getModuleNameStringLiteralAt(file, index)); @@ -890,7 +889,6 @@ export function isExclusivelyTypeOnlyImportOrExport(decl: ImportDeclaration | Ex * @returns The final resolution mode of the import */ export function getModeForUsageLocation(file: { impliedNodeFormat?: ResolutionMode; }, usage: StringLiteralLike) { - if (file.impliedNodeFormat === undefined) return undefined; if ((isImportDeclaration(usage.parent) || isExportDeclaration(usage.parent))) { const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage.parent); if (isTypeOnly) { @@ -906,6 +904,7 @@ export function getModeForUsageLocation(file: { impliedNodeFormat?: ResolutionMo return override; } } + if (file.impliedNodeFormat === undefined) return undefined; if (file.impliedNodeFormat !== ModuleKind.ESNext) { // in cjs files, import call expressions are esm format, otherwise everything is cjs return isImportCall(walkUpParenthesizedExpressions(usage.parent)) ? ModuleKind.ESNext : ModuleKind.CommonJS; @@ -3841,14 +3840,6 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg const fileName = toFileNameLowerCase(ref.fileName); setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat)); const mode = ref.resolutionMode || file.impliedNodeFormat; - if (mode && getEmitModuleResolutionKind(options) !== ModuleResolutionKind.Node16 && getEmitModuleResolutionKind(options) !== ModuleResolutionKind.NodeNext) { - (fileProcessingDiagnostics ??= []).push({ - kind: FilePreprocessingDiagnosticsKind.ResolutionDiagnostics, - diagnostics: [ - createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext), - ], - }); - } processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: FileIncludeKind.TypeReferenceDirective, file: file.path, index }); } } diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).symbols b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).symbols new file mode 100644 index 0000000000000..3b36b51d0afa7 --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +=== /app.ts === +type Default = typeof import("foo").x; +>Default : Symbol(Default, Decl(app.ts, 0, 0)) +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +>Import : Symbol(Import, Decl(app.ts, 0, 38)) +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +>Require : Symbol(Require, Decl(app.ts, 1, 82)) +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 2, 84)) +>x : Symbol(x, Decl(other.ts, 0, 12)) + +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 4, 94)) +>x : Symbol(x, Decl(other.ts, 0, 12)) + +=== /other.ts === +export const x = "other"; +>x : Symbol(x, Decl(other.ts, 0, 12)) + diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).types b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).types new file mode 100644 index 0000000000000..f3c63d21500ce --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=bundler).types @@ -0,0 +1,37 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : "module" + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : "script" + +=== /app.ts === +type Default = typeof import("foo").x; +>Default : "module" +>x : error + +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +>Import : "module" +>x : error + +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +>Require : "script" +>x : error + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +>ImportRelative : "other" +>x : error + +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; +>RequireRelative : "other" +>x : error + +=== /other.ts === +export const x = "other"; +>x : "other" +>"other" : "other" + diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).errors.txt b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).errors.txt new file mode 100644 index 0000000000000..f7596129d6f40 --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).errors.txt @@ -0,0 +1,46 @@ +error TS2688: Cannot find type definition file for 'foo'. + The file is in the program because: + Entry point for implicit type library 'foo' +/app.ts(1,30): error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? +/app.ts(2,29): error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? +/app.ts(3,30): error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + + +!!! error TS2688: Cannot find type definition file for 'foo'. +!!! error TS2688: The file is in the program because: +!!! error TS2688: Entry point for implicit type library 'foo' +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export declare const x: "module"; + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export declare const x: "script"; + +==== /app.ts (3 errors) ==== + type Default = typeof import("foo").x; + ~~~~~ +!!! error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; + ~~~~~ +!!! error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; + ~~~~~ +!!! error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + // resolution-mode does not enforce file extension in `bundler`, just sets conditions + type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; + type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; + +==== /other.ts (0 errors) ==== + export const x = "other"; + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).symbols b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).symbols new file mode 100644 index 0000000000000..5d3941b76cc7c --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +=== /app.ts === +type Default = typeof import("foo").x; +>Default : Symbol(Default, Decl(app.ts, 0, 0)) + +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +>Import : Symbol(Import, Decl(app.ts, 0, 38)) + +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +>Require : Symbol(Require, Decl(app.ts, 1, 82)) + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 2, 84)) +>x : Symbol(x, Decl(other.ts, 0, 12)) + +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 4, 94)) +>x : Symbol(x, Decl(other.ts, 0, 12)) + +=== /other.ts === +export const x = "other"; +>x : Symbol(x, Decl(other.ts, 0, 12)) + diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).types b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).types new file mode 100644 index 0000000000000..bc1037abadf8e --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=classic).types @@ -0,0 +1,37 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : "module" + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : "script" + +=== /app.ts === +type Default = typeof import("foo").x; +>Default : any +>x : any + +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +>Import : any +>x : any + +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +>Require : any +>x : any + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +>ImportRelative : "other" +>x : any + +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; +>RequireRelative : "other" +>x : any + +=== /other.ts === +export const x = "other"; +>x : "other" +>"other" : "other" + diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).errors.txt b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).errors.txt new file mode 100644 index 0000000000000..61dafd0967d69 --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).errors.txt @@ -0,0 +1,40 @@ +error TS2688: Cannot find type definition file for 'foo'. + The file is in the program because: + Entry point for implicit type library 'foo' +/app.ts(1,30): error TS2307: Cannot find module 'foo' or its corresponding type declarations. + + +!!! error TS2688: Cannot find type definition file for 'foo'. +!!! error TS2688: The file is in the program because: +!!! error TS2688: Entry point for implicit type library 'foo' +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export declare const x: "module"; + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export declare const x: "script"; + +==== /app.ts (1 errors) ==== + type Default = typeof import("foo").x; + ~~~~~ +!!! error TS2307: Cannot find module 'foo' or its corresponding type declarations. + type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; + type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; + // resolution-mode does not enforce file extension in `bundler`, just sets conditions + type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; + type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; + +==== /other.ts (0 errors) ==== + export const x = "other"; + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).symbols b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).symbols new file mode 100644 index 0000000000000..e83a9671ea382 --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).symbols @@ -0,0 +1,35 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +=== /app.ts === +type Default = typeof import("foo").x; +>Default : Symbol(Default, Decl(app.ts, 0, 0)) + +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +>Import : Symbol(Import, Decl(app.ts, 0, 38)) +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +>Require : Symbol(Require, Decl(app.ts, 1, 82)) +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 2, 84)) +>x : Symbol(x, Decl(other.ts, 0, 12)) + +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 4, 94)) +>x : Symbol(x, Decl(other.ts, 0, 12)) + +=== /other.ts === +export const x = "other"; +>x : Symbol(x, Decl(other.ts, 0, 12)) + diff --git a/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).types b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).types new file mode 100644 index 0000000000000..ad88d6531656b --- /dev/null +++ b/tests/baselines/reference/resolutionModeImportType1(moduleresolution=node10).types @@ -0,0 +1,37 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : "module" + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : "script" + +=== /app.ts === +type Default = typeof import("foo").x; +>Default : any +>x : any + +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +>Import : "module" +>x : any + +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +>Require : "script" +>x : any + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +>ImportRelative : "other" +>x : any + +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; +>RequireRelative : "other" +>x : any + +=== /other.ts === +export const x = "other"; +>x : "other" +>"other" : "other" + diff --git a/tests/baselines/reference/resolutionModeTripleSlash1.errors.txt b/tests/baselines/reference/resolutionModeTripleSlash1.errors.txt new file mode 100644 index 0000000000000..963acbfbf25d1 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTripleSlash1.errors.txt @@ -0,0 +1,45 @@ +/app.ts(3,1): error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? + + +==== /tsconfig.json (0 errors) ==== + { + "compilerOptions": { + "module": "esnext", + "moduleResolution": "bundler", + "noEmit": true, + "types": [] + } + } + +==== /app.ts (1 errors) ==== + /// + MODULE; // ok + SCRIPT; // error + ~~~~~~ +!!! error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? +!!! related TS2728 lib.scripthost.d.ts:--:--: 'WScript' is declared here. + +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export {}; + declare global { + const MODULE: any; + } + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export {}; + declare global { + const SCRIPT: any; + } + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt b/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt new file mode 100644 index 0000000000000..cc6d3553d1735 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt @@ -0,0 +1,45 @@ +/app.ts(2,1): error TS2304: Cannot find name 'MODULE'. + + +==== /tsconfig.json (0 errors) ==== + { + "compilerOptions": { + "module": "esnext", + "moduleResolution": "bundler", + "declaration": true, + "emitDeclarationOnly": true, + "types": [] + } + } + +==== /app.ts (1 errors) ==== + /// + MODULE; // error + ~~~~~~ +!!! error TS2304: Cannot find name 'MODULE'. + SCRIPT; // ok + +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export {}; + declare global { + const MODULE: any; + } + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export {}; + declare global { + const SCRIPT: any; + } + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTripleSlash2.js b/tests/baselines/reference/resolutionModeTripleSlash2.js new file mode 100644 index 0000000000000..d55508989ee85 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTripleSlash2.js @@ -0,0 +1,35 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts] //// + +//// [package.json] +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +//// [index.d.mts] +export {}; +declare global { + const MODULE: any; +} + +//// [index.d.cts] +export {}; +declare global { + const SCRIPT: any; +} + +//// [app.ts] +/// +MODULE; // error +SCRIPT; // ok + + + + +//// [app.d.ts] diff --git a/tests/baselines/reference/resolutionModeTripleSlash3.errors.txt b/tests/baselines/reference/resolutionModeTripleSlash3.errors.txt new file mode 100644 index 0000000000000..e0f57ac5b81c5 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTripleSlash3.errors.txt @@ -0,0 +1,45 @@ +/app.ts(3,1): error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? + + +==== /tsconfig.json (0 errors) ==== + { + "compilerOptions": { + "module": "esnext", + "moduleResolution": "bundler", + "noEmit": true, + "types": [] + } + } + +==== /app.ts (1 errors) ==== + /// + MODULE; // ok + SCRIPT; // error + ~~~~~~ +!!! error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? +!!! related TS2728 lib.scripthost.d.ts:--:--: 'WScript' is declared here. + +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export {}; + declare global { + const MODULE: any; + } + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export {}; + declare global { + const SCRIPT: any; + } + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTripleSlash4.errors.txt b/tests/baselines/reference/resolutionModeTripleSlash4.errors.txt new file mode 100644 index 0000000000000..81626cc54b2f6 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTripleSlash4.errors.txt @@ -0,0 +1,51 @@ +/app.ts(1,23): error TS2688: Cannot find type definition file for 'foo'. +/app.ts(2,1): error TS2304: Cannot find name 'MODULE'. +/app.ts(3,1): error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? + + +==== /tsconfig.json (0 errors) ==== + { + "compilerOptions": { + "module": "esnext", + "moduleResolution": "node10", + "noEmit": true, + "types": [] + } + } + +==== /app.ts (3 errors) ==== + /// + ~~~ +!!! error TS2688: Cannot find type definition file for 'foo'. + MODULE; // error + ~~~~~~ +!!! error TS2304: Cannot find name 'MODULE'. + SCRIPT; // error + ~~~~~~ +!!! error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? +!!! related TS2728 lib.scripthost.d.ts:--:--: 'WScript' is declared here. + +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export {}; + declare global { + const MODULE: any; + } + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export {}; + declare global { + const SCRIPT: any; + } + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTripleSlash5.errors.txt b/tests/baselines/reference/resolutionModeTripleSlash5.errors.txt new file mode 100644 index 0000000000000..6618295aa9e5c --- /dev/null +++ b/tests/baselines/reference/resolutionModeTripleSlash5.errors.txt @@ -0,0 +1,45 @@ +/app.ts(3,1): error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? + + +==== /tsconfig.json (0 errors) ==== + { + "compilerOptions": { + "module": "esnext", + "moduleResolution": "node10", + "noEmit": true, + "types": [] + } + } + +==== /app.ts (1 errors) ==== + /// + MODULE; // ok + SCRIPT; // error + ~~~~~~ +!!! error TS2552: Cannot find name 'SCRIPT'. Did you mean 'WScript'? +!!! related TS2728 lib.scripthost.d.ts:--:--: 'WScript' is declared here. + +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export {}; + declare global { + const MODULE: any; + } + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export {}; + declare global { + const SCRIPT: any; + } + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js new file mode 100644 index 0000000000000..582022509184a --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js @@ -0,0 +1,44 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +//// [package.json] +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +//// [index.d.mts] +export declare const x: "module"; + +//// [index.d.cts] +export declare const x: "script"; + +//// [app.ts] +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; + +//// [other.ts] +export const x = "other"; + + + + +//// [other.d.ts] +export declare const x = "other"; +//// [app.d.ts] +export {}; diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols new file mode 100644 index 0000000000000..c5aa45dadcf0a --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols @@ -0,0 +1,56 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +=== /app.ts === +import type { x as Default } from "foo"; +>x : Symbol(Default, Decl(index.d.mts, 0, 20)) +>Default : Symbol(Default, Decl(app.ts, 0, 13)) + +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +>x : Symbol(Default, Decl(index.d.mts, 0, 20)) +>Import : Symbol(Import, Decl(app.ts, 1, 13)) + +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +>x : Symbol(Require, Decl(index.d.cts, 0, 20)) +>Require : Symbol(Require, Decl(app.ts, 2, 13)) + +type _Default = typeof Default; +>_Default : Symbol(_Default, Decl(app.ts, 2, 80)) +>Default : Symbol(Default, Decl(app.ts, 0, 13)) + +type _Import = typeof Import; +>_Import : Symbol(_Import, Decl(app.ts, 3, 31)) +>Import : Symbol(Import, Decl(app.ts, 1, 13)) + +type _Require = typeof Require; +>_Require : Symbol(_Require, Decl(app.ts, 4, 29)) +>Require : Symbol(Require, Decl(app.ts, 2, 13)) + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +>x : Symbol(ImportRelative, Decl(other.ts, 0, 12)) +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 8, 13)) + +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +>x : Symbol(ImportRelative, Decl(other.ts, 0, 12)) +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) + +type _ImportRelative = typeof ImportRelative; +>_ImportRelative : Symbol(_ImportRelative, Decl(app.ts, 9, 92)) +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 8, 13)) + +type _RequireRelative = typeof RequireRelative; +>_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 10, 45)) +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) + +=== /other.ts === +export const x = "other"; +>x : Symbol(x, Decl(other.ts, 0, 12)) + diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types new file mode 100644 index 0000000000000..36013c189a959 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types @@ -0,0 +1,57 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : "module" + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : "script" + +=== /app.ts === +import type { x as Default } from "foo"; +>x : "module" +>Default : any + +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +>x : "module" +>Import : any + +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +>x : "script" +>Require : any + +type _Default = typeof Default; +>_Default : "module" +>Default : "module" + +type _Import = typeof Import; +>_Import : "module" +>Import : "module" + +type _Require = typeof Require; +>_Require : "script" +>Require : "script" + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +>x : "other" +>ImportRelative : any + +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +>x : "other" +>RequireRelative : any + +type _ImportRelative = typeof ImportRelative; +>_ImportRelative : "other" +>ImportRelative : "other" + +type _RequireRelative = typeof RequireRelative; +>_RequireRelative : "other" +>RequireRelative : "other" + +=== /other.ts === +export const x = "other"; +>x : "other" +>"other" : "other" + diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt new file mode 100644 index 0000000000000..b11e6fbc7eb85 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt @@ -0,0 +1,52 @@ +error TS2688: Cannot find type definition file for 'foo'. + The file is in the program because: + Entry point for implicit type library 'foo' +/app.ts(1,35): error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? +/app.ts(2,34): error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? +/app.ts(3,35): error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + + +!!! error TS2688: Cannot find type definition file for 'foo'. +!!! error TS2688: The file is in the program because: +!!! error TS2688: Entry point for implicit type library 'foo' +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export declare const x: "module"; + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export declare const x: "script"; + +==== /app.ts (3 errors) ==== + import type { x as Default } from "foo"; + ~~~~~ +!!! error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + import type { x as Import } from "foo" assert { "resolution-mode": "import" }; + ~~~~~ +!!! error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + import type { x as Require } from "foo" assert { "resolution-mode": "require" }; + ~~~~~ +!!! error TS2792: Cannot find module 'foo'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option? + type _Default = typeof Default; + type _Import = typeof Import; + type _Require = typeof Require; + + // resolution-mode does not enforce file extension in `bundler`, just sets conditions + import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; + import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; + type _ImportRelative = typeof ImportRelative; + type _RequireRelative = typeof RequireRelative; + +==== /other.ts (0 errors) ==== + export const x = "other"; + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js new file mode 100644 index 0000000000000..582022509184a --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js @@ -0,0 +1,44 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +//// [package.json] +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +//// [index.d.mts] +export declare const x: "module"; + +//// [index.d.cts] +export declare const x: "script"; + +//// [app.ts] +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; + +//// [other.ts] +export const x = "other"; + + + + +//// [other.d.ts] +export declare const x = "other"; +//// [app.d.ts] +export {}; diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols new file mode 100644 index 0000000000000..6015a183d900a --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols @@ -0,0 +1,53 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +=== /app.ts === +import type { x as Default } from "foo"; +>Default : Symbol(Default, Decl(app.ts, 0, 13)) + +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +>Import : Symbol(Import, Decl(app.ts, 1, 13)) + +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +>Require : Symbol(Require, Decl(app.ts, 2, 13)) + +type _Default = typeof Default; +>_Default : Symbol(_Default, Decl(app.ts, 2, 80)) +>Default : Symbol(Default, Decl(app.ts, 0, 13)) + +type _Import = typeof Import; +>_Import : Symbol(_Import, Decl(app.ts, 3, 31)) +>Import : Symbol(Import, Decl(app.ts, 1, 13)) + +type _Require = typeof Require; +>_Require : Symbol(_Require, Decl(app.ts, 4, 29)) +>Require : Symbol(Require, Decl(app.ts, 2, 13)) + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +>x : Symbol(ImportRelative, Decl(other.ts, 0, 12)) +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 8, 13)) + +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +>x : Symbol(ImportRelative, Decl(other.ts, 0, 12)) +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) + +type _ImportRelative = typeof ImportRelative; +>_ImportRelative : Symbol(_ImportRelative, Decl(app.ts, 9, 92)) +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 8, 13)) + +type _RequireRelative = typeof RequireRelative; +>_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 10, 45)) +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) + +=== /other.ts === +export const x = "other"; +>x : Symbol(x, Decl(other.ts, 0, 12)) + diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types new file mode 100644 index 0000000000000..0f88d07152bad --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types @@ -0,0 +1,57 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : "module" + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : "script" + +=== /app.ts === +import type { x as Default } from "foo"; +>x : any +>Default : any + +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +>x : any +>Import : any + +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +>x : any +>Require : any + +type _Default = typeof Default; +>_Default : any +>Default : any + +type _Import = typeof Import; +>_Import : any +>Import : any + +type _Require = typeof Require; +>_Require : any +>Require : any + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +>x : "other" +>ImportRelative : any + +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +>x : "other" +>RequireRelative : any + +type _ImportRelative = typeof ImportRelative; +>_ImportRelative : "other" +>ImportRelative : "other" + +type _RequireRelative = typeof RequireRelative; +>_RequireRelative : "other" +>RequireRelative : "other" + +=== /other.ts === +export const x = "other"; +>x : "other" +>"other" : "other" + diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt new file mode 100644 index 0000000000000..49ed93293a650 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt @@ -0,0 +1,46 @@ +error TS2688: Cannot find type definition file for 'foo'. + The file is in the program because: + Entry point for implicit type library 'foo' +/app.ts(1,35): error TS2307: Cannot find module 'foo' or its corresponding type declarations. + + +!!! error TS2688: Cannot find type definition file for 'foo'. +!!! error TS2688: The file is in the program because: +!!! error TS2688: Entry point for implicit type library 'foo' +==== /node_modules/@types/foo/package.json (0 errors) ==== + { + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } + } + +==== /node_modules/@types/foo/index.d.mts (0 errors) ==== + export declare const x: "module"; + +==== /node_modules/@types/foo/index.d.cts (0 errors) ==== + export declare const x: "script"; + +==== /app.ts (1 errors) ==== + import type { x as Default } from "foo"; + ~~~~~ +!!! error TS2307: Cannot find module 'foo' or its corresponding type declarations. + import type { x as Import } from "foo" assert { "resolution-mode": "import" }; + import type { x as Require } from "foo" assert { "resolution-mode": "require" }; + type _Default = typeof Default; + type _Import = typeof Import; + type _Require = typeof Require; + + // resolution-mode does not enforce file extension in `bundler`, just sets conditions + import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; + import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; + type _ImportRelative = typeof ImportRelative; + type _RequireRelative = typeof RequireRelative; + +==== /other.ts (0 errors) ==== + export const x = "other"; + \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js new file mode 100644 index 0000000000000..582022509184a --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js @@ -0,0 +1,44 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +//// [package.json] +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +//// [index.d.mts] +export declare const x: "module"; + +//// [index.d.cts] +export declare const x: "script"; + +//// [app.ts] +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; + +//// [other.ts] +export const x = "other"; + + + + +//// [other.d.ts] +export declare const x = "other"; +//// [app.d.ts] +export {}; diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols new file mode 100644 index 0000000000000..158d11679ec88 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols @@ -0,0 +1,55 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : Symbol(x, Decl(index.d.mts, 0, 20)) + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : Symbol(x, Decl(index.d.cts, 0, 20)) + +=== /app.ts === +import type { x as Default } from "foo"; +>Default : Symbol(Default, Decl(app.ts, 0, 13)) + +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +>x : Symbol(Import, Decl(index.d.mts, 0, 20)) +>Import : Symbol(Import, Decl(app.ts, 1, 13)) + +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +>x : Symbol(Require, Decl(index.d.cts, 0, 20)) +>Require : Symbol(Require, Decl(app.ts, 2, 13)) + +type _Default = typeof Default; +>_Default : Symbol(_Default, Decl(app.ts, 2, 80)) +>Default : Symbol(Default, Decl(app.ts, 0, 13)) + +type _Import = typeof Import; +>_Import : Symbol(_Import, Decl(app.ts, 3, 31)) +>Import : Symbol(Import, Decl(app.ts, 1, 13)) + +type _Require = typeof Require; +>_Require : Symbol(_Require, Decl(app.ts, 4, 29)) +>Require : Symbol(Require, Decl(app.ts, 2, 13)) + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +>x : Symbol(ImportRelative, Decl(other.ts, 0, 12)) +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 8, 13)) + +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +>x : Symbol(ImportRelative, Decl(other.ts, 0, 12)) +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) + +type _ImportRelative = typeof ImportRelative; +>_ImportRelative : Symbol(_ImportRelative, Decl(app.ts, 9, 92)) +>ImportRelative : Symbol(ImportRelative, Decl(app.ts, 8, 13)) + +type _RequireRelative = typeof RequireRelative; +>_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 10, 45)) +>RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) + +=== /other.ts === +export const x = "other"; +>x : Symbol(x, Decl(other.ts, 0, 12)) + diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types new file mode 100644 index 0000000000000..1782d546c27c7 --- /dev/null +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types @@ -0,0 +1,57 @@ +//// [tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts] //// + +=== /node_modules/@types/foo/index.d.mts === +export declare const x: "module"; +>x : "module" + +=== /node_modules/@types/foo/index.d.cts === +export declare const x: "script"; +>x : "script" + +=== /app.ts === +import type { x as Default } from "foo"; +>x : any +>Default : any + +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +>x : "module" +>Import : any + +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +>x : "script" +>Require : any + +type _Default = typeof Default; +>_Default : any +>Default : any + +type _Import = typeof Import; +>_Import : "module" +>Import : "module" + +type _Require = typeof Require; +>_Require : "script" +>Require : "script" + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +>x : "other" +>ImportRelative : any + +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +>x : "other" +>RequireRelative : any + +type _ImportRelative = typeof ImportRelative; +>_ImportRelative : "other" +>ImportRelative : "other" + +type _RequireRelative = typeof RequireRelative; +>_RequireRelative : "other" +>RequireRelative : "other" + +=== /other.ts === +export const x = "other"; +>x : "other" +>"other" : "other" + diff --git a/tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts b/tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts new file mode 100644 index 0000000000000..9c29af37a654e --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeImportType1.ts @@ -0,0 +1,32 @@ +// @module: esnext +// @moduleResolution: bundler, node10, classic +// @noEmit: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export declare const x: "module"; + +// @Filename: /node_modules/@types/foo/index.d.cts +export declare const x: "script"; + +// @Filename: /app.ts +type Default = typeof import("foo").x; +type Import = typeof import("foo", { assert: { "resolution-mode": "import" } }).x; +type Require = typeof import("foo", { assert: { "resolution-mode": "require" } }).x; +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +type ImportRelative = typeof import("./other", { assert: { "resolution-mode": "import" } }).x; +type RequireRelative = typeof import("./other", { assert: { "resolution-mode": "require" } }).x; + +// @Filename: /other.ts +export const x = "other"; diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash1.ts b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash1.ts new file mode 100644 index 0000000000000..2049afd48718d --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash1.ts @@ -0,0 +1,40 @@ +// @noTypesAndSymbols: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export {}; +declare global { + const MODULE: any; +} + +//@Filename: /node_modules/@types/foo/index.d.cts +export {}; +declare global { + const SCRIPT: any; +} + +// @Filename: /tsconfig.json +{ + "compilerOptions": { + "module": "esnext", + "moduleResolution": "bundler", + "noEmit": true, + "types": [] + } +} + +// @Filename: /app.ts +/// +MODULE; // ok +SCRIPT; // error diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts new file mode 100644 index 0000000000000..3d4bf0edc334a --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts @@ -0,0 +1,41 @@ +// @noTypesAndSymbols: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export {}; +declare global { + const MODULE: any; +} + +//@Filename: /node_modules/@types/foo/index.d.cts +export {}; +declare global { + const SCRIPT: any; +} + +// @Filename: /tsconfig.json +{ + "compilerOptions": { + "module": "esnext", + "moduleResolution": "bundler", + "declaration": true, + "emitDeclarationOnly": true, + "types": [] + } +} + +// @Filename: /app.ts +/// +MODULE; // error +SCRIPT; // ok diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash3.ts b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash3.ts new file mode 100644 index 0000000000000..8f3516eb89e59 --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash3.ts @@ -0,0 +1,40 @@ +// @noTypesAndSymbols: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export {}; +declare global { + const MODULE: any; +} + +//@Filename: /node_modules/@types/foo/index.d.cts +export {}; +declare global { + const SCRIPT: any; +} + +// @Filename: /tsconfig.json +{ + "compilerOptions": { + "module": "esnext", + "moduleResolution": "bundler", + "noEmit": true, + "types": [] + } +} + +// @Filename: /app.ts +/// +MODULE; // ok +SCRIPT; // error diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash4.ts b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash4.ts new file mode 100644 index 0000000000000..3602b1df25016 --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash4.ts @@ -0,0 +1,40 @@ +// @noTypesAndSymbols: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export {}; +declare global { + const MODULE: any; +} + +//@Filename: /node_modules/@types/foo/index.d.cts +export {}; +declare global { + const SCRIPT: any; +} + +// @Filename: /tsconfig.json +{ + "compilerOptions": { + "module": "esnext", + "moduleResolution": "node10", + "noEmit": true, + "types": [] + } +} + +// @Filename: /app.ts +/// +MODULE; // error +SCRIPT; // error diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash5.ts b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash5.ts new file mode 100644 index 0000000000000..eee5023aebfec --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash5.ts @@ -0,0 +1,40 @@ +// @noTypesAndSymbols: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export {}; +declare global { + const MODULE: any; +} + +//@Filename: /node_modules/@types/foo/index.d.cts +export {}; +declare global { + const SCRIPT: any; +} + +// @Filename: /tsconfig.json +{ + "compilerOptions": { + "module": "esnext", + "moduleResolution": "node10", + "noEmit": true, + "types": [] + } +} + +// @Filename: /app.ts +/// +MODULE; // ok +SCRIPT; // error diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts b/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts new file mode 100644 index 0000000000000..a09b01b46c9f2 --- /dev/null +++ b/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts @@ -0,0 +1,39 @@ +// @module: esnext +// @moduleResolution: bundler, node10, classic +// @declaration: true +// @emitDeclarationOnly: true + +// @Filename: /node_modules/@types/foo/package.json +{ + "name": "@types/foo", + "version": "1.0.0", + "exports": { + ".": { + "import": "./index.d.mts", + "require": "./index.d.cts" + } + } +} + +// @Filename: /node_modules/@types/foo/index.d.mts +export declare const x: "module"; + +// @Filename: /node_modules/@types/foo/index.d.cts +export declare const x: "script"; + +// @Filename: /app.ts +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; + +// resolution-mode does not enforce file extension in `bundler`, just sets conditions +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; + +// @Filename: /other.ts +export const x = "other"; From 812c1e9df331197e48651dd1cbc20d882f94ce33 Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 12 Sep 2023 14:59:49 -0700 Subject: [PATCH 2/9] Ensure imports are needed in declaration emit for tests --- ...peOnlyImport1(moduleresolution=bundler).js | 20 ++++++++++++++++++- ...yImport1(moduleresolution=bundler).symbols | 17 ++++++++++++++++ ...nlyImport1(moduleresolution=bundler).types | 17 ++++++++++++++++ ...port1(moduleresolution=classic).errors.txt | 8 ++++++++ ...peOnlyImport1(moduleresolution=classic).js | 20 ++++++++++++++++++- ...yImport1(moduleresolution=classic).symbols | 17 ++++++++++++++++ ...nlyImport1(moduleresolution=classic).types | 17 ++++++++++++++++ ...mport1(moduleresolution=node10).errors.txt | 8 ++++++++ ...ypeOnlyImport1(moduleresolution=node10).js | 20 ++++++++++++++++++- ...lyImport1(moduleresolution=node10).symbols | 17 ++++++++++++++++ ...OnlyImport1(moduleresolution=node10).types | 17 ++++++++++++++++ .../resolutionModeTripleSlash2.ts | 3 +++ .../resolutionModeTypeOnlyImport1.ts | 8 ++++++++ 13 files changed, 186 insertions(+), 3 deletions(-) diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js index 582022509184a..961512bfab79f 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).js @@ -31,6 +31,14 @@ import type { x as ImportRelative } from "./other" assert { "resolution-mode": " import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; type _ImportRelative = typeof ImportRelative; type _RequireRelative = typeof RequireRelative; + +export { + _Default, + _Import, + _Require, + _ImportRelative, + _RequireRelative +} //// [other.ts] export const x = "other"; @@ -41,4 +49,14 @@ export const x = "other"; //// [other.d.ts] export declare const x = "other"; //// [app.d.ts] -export {}; +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; +export { _Default, _Import, _Require, _ImportRelative, _RequireRelative }; diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols index c5aa45dadcf0a..1d28242ebf843 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).symbols @@ -50,6 +50,23 @@ type _RequireRelative = typeof RequireRelative; >_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 10, 45)) >RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) +export { + _Default, +>_Default : Symbol(_Default, Decl(app.ts, 13, 8)) + + _Import, +>_Import : Symbol(_Import, Decl(app.ts, 14, 11)) + + _Require, +>_Require : Symbol(_Require, Decl(app.ts, 15, 10)) + + _ImportRelative, +>_ImportRelative : Symbol(_ImportRelative, Decl(app.ts, 16, 11)) + + _RequireRelative +>_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 17, 18)) +} + === /other.ts === export const x = "other"; >x : Symbol(x, Decl(other.ts, 0, 12)) diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types index 36013c189a959..404083065a83d 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=bundler).types @@ -50,6 +50,23 @@ type _RequireRelative = typeof RequireRelative; >_RequireRelative : "other" >RequireRelative : "other" +export { + _Default, +>_Default : any + + _Import, +>_Import : any + + _Require, +>_Require : any + + _ImportRelative, +>_ImportRelative : any + + _RequireRelative +>_RequireRelative : any +} + === /other.ts === export const x = "other"; >x : "other" diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt index b11e6fbc7eb85..8e52a8e3c12ce 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).errors.txt @@ -47,6 +47,14 @@ error TS2688: Cannot find type definition file for 'foo'. type _ImportRelative = typeof ImportRelative; type _RequireRelative = typeof RequireRelative; + export { + _Default, + _Import, + _Require, + _ImportRelative, + _RequireRelative + } + ==== /other.ts (0 errors) ==== export const x = "other"; \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js index 582022509184a..961512bfab79f 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).js @@ -31,6 +31,14 @@ import type { x as ImportRelative } from "./other" assert { "resolution-mode": " import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; type _ImportRelative = typeof ImportRelative; type _RequireRelative = typeof RequireRelative; + +export { + _Default, + _Import, + _Require, + _ImportRelative, + _RequireRelative +} //// [other.ts] export const x = "other"; @@ -41,4 +49,14 @@ export const x = "other"; //// [other.d.ts] export declare const x = "other"; //// [app.d.ts] -export {}; +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; +export { _Default, _Import, _Require, _ImportRelative, _RequireRelative }; diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols index 6015a183d900a..a9c303545a796 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).symbols @@ -47,6 +47,23 @@ type _RequireRelative = typeof RequireRelative; >_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 10, 45)) >RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) +export { + _Default, +>_Default : Symbol(_Default, Decl(app.ts, 13, 8)) + + _Import, +>_Import : Symbol(_Import, Decl(app.ts, 14, 11)) + + _Require, +>_Require : Symbol(_Require, Decl(app.ts, 15, 10)) + + _ImportRelative, +>_ImportRelative : Symbol(_ImportRelative, Decl(app.ts, 16, 11)) + + _RequireRelative +>_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 17, 18)) +} + === /other.ts === export const x = "other"; >x : Symbol(x, Decl(other.ts, 0, 12)) diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types index 0f88d07152bad..fae95dc236b7a 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=classic).types @@ -50,6 +50,23 @@ type _RequireRelative = typeof RequireRelative; >_RequireRelative : "other" >RequireRelative : "other" +export { + _Default, +>_Default : any + + _Import, +>_Import : any + + _Require, +>_Require : any + + _ImportRelative, +>_ImportRelative : any + + _RequireRelative +>_RequireRelative : any +} + === /other.ts === export const x = "other"; >x : "other" diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt index 49ed93293a650..e0030925c182d 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).errors.txt @@ -41,6 +41,14 @@ error TS2688: Cannot find type definition file for 'foo'. type _ImportRelative = typeof ImportRelative; type _RequireRelative = typeof RequireRelative; + export { + _Default, + _Import, + _Require, + _ImportRelative, + _RequireRelative + } + ==== /other.ts (0 errors) ==== export const x = "other"; \ No newline at end of file diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js index 582022509184a..961512bfab79f 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).js @@ -31,6 +31,14 @@ import type { x as ImportRelative } from "./other" assert { "resolution-mode": " import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; type _ImportRelative = typeof ImportRelative; type _RequireRelative = typeof RequireRelative; + +export { + _Default, + _Import, + _Require, + _ImportRelative, + _RequireRelative +} //// [other.ts] export const x = "other"; @@ -41,4 +49,14 @@ export const x = "other"; //// [other.d.ts] export declare const x = "other"; //// [app.d.ts] -export {}; +import type { x as Default } from "foo"; +import type { x as Import } from "foo" assert { "resolution-mode": "import" }; +import type { x as Require } from "foo" assert { "resolution-mode": "require" }; +type _Default = typeof Default; +type _Import = typeof Import; +type _Require = typeof Require; +import type { x as ImportRelative } from "./other" assert { "resolution-mode": "import" }; +import type { x as RequireRelative } from "./other" assert { "resolution-mode": "require" }; +type _ImportRelative = typeof ImportRelative; +type _RequireRelative = typeof RequireRelative; +export { _Default, _Import, _Require, _ImportRelative, _RequireRelative }; diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols index 158d11679ec88..fd0c9f96b57a3 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).symbols @@ -49,6 +49,23 @@ type _RequireRelative = typeof RequireRelative; >_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 10, 45)) >RequireRelative : Symbol(RequireRelative, Decl(app.ts, 9, 13)) +export { + _Default, +>_Default : Symbol(_Default, Decl(app.ts, 13, 8)) + + _Import, +>_Import : Symbol(_Import, Decl(app.ts, 14, 11)) + + _Require, +>_Require : Symbol(_Require, Decl(app.ts, 15, 10)) + + _ImportRelative, +>_ImportRelative : Symbol(_ImportRelative, Decl(app.ts, 16, 11)) + + _RequireRelative +>_RequireRelative : Symbol(_RequireRelative, Decl(app.ts, 17, 18)) +} + === /other.ts === export const x = "other"; >x : Symbol(x, Decl(other.ts, 0, 12)) diff --git a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types index 1782d546c27c7..6e1edbf27b29d 100644 --- a/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types +++ b/tests/baselines/reference/resolutionModeTypeOnlyImport1(moduleresolution=node10).types @@ -50,6 +50,23 @@ type _RequireRelative = typeof RequireRelative; >_RequireRelative : "other" >RequireRelative : "other" +export { + _Default, +>_Default : any + + _Import, +>_Import : any + + _Require, +>_Require : any + + _ImportRelative, +>_ImportRelative : any + + _RequireRelative +>_RequireRelative : any +} + === /other.ts === export const x = "other"; >x : "other" diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts index 3d4bf0edc334a..ed87315448da3 100644 --- a/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts +++ b/tests/cases/conformance/moduleResolution/resolutionModeTripleSlash2.ts @@ -39,3 +39,6 @@ declare global { /// MODULE; // error SCRIPT; // ok +function foo() { + return SCRIPT; +} \ No newline at end of file diff --git a/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts b/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts index a09b01b46c9f2..24ccc38c0034d 100644 --- a/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts +++ b/tests/cases/conformance/moduleResolution/resolutionModeTypeOnlyImport1.ts @@ -35,5 +35,13 @@ import type { x as RequireRelative } from "./other" assert { "resolution-mode": type _ImportRelative = typeof ImportRelative; type _RequireRelative = typeof RequireRelative; +export { + _Default, + _Import, + _Require, + _ImportRelative, + _RequireRelative +} + // @Filename: /other.ts export const x = "other"; From 990af586b16f6d887983d619ab6ff544764cfad1 Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 12 Sep 2023 15:16:15 -0700 Subject: [PATCH 3/9] Make bundlerModuleNameResolver signature change internal --- src/compiler/moduleNameResolver.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index cc2eb0f90131a..cfacac0b8c512 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -1734,7 +1734,9 @@ function tryResolveJSModuleWorker(moduleName: string, initialDir: string, host: /*overrideResolutionMode*/ undefined, ); } - +export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; +/** @internal */ +export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations; export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations { const containingDirectory = getDirectoryPath(containingFile); let extensions = compilerOptions.noDtsResolution ? Extensions.ImplementationFiles : Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration; From 53adb192e6ec2374c66c024a54c73bdf8520604e Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 19 Sep 2023 10:25:09 -0700 Subject: [PATCH 4/9] Make worker functions take conditions instead of resolutionModeOverride --- src/compiler/moduleNameResolver.ts | 74 ++++++++++--------- ...eModeOverrideOldResolutionError.errors.txt | 45 ----------- ...enceModeOverrideOldResolutionError.symbols | 23 +++++- ...erenceModeOverrideOldResolutionError.types | 22 +++++- .../resolutionModeTripleSlash2.errors.txt | 4 +- .../reference/resolutionModeTripleSlash2.js | 5 +- ...ReferenceModeOverrideOldResolutionError.ts | 2 +- 7 files changed, 86 insertions(+), 89 deletions(-) delete mode 100644 tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.errors.txt diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index cfacac0b8c512..bae8747c37997 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -308,7 +308,6 @@ export interface ModuleResolutionState { reportDiagnostic: DiagnosticReporter; isConfigLookup: boolean; candidateIsFromPackageJsonField: boolean; - overrideResolutionMode: ResolutionMode; } /** Just the fields that we use for module resolution. @@ -563,7 +562,7 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string // when a `resolution-mode` override is present. let features = getNodeResolutionFeatures(options); if (resolutionMode !== undefined) { - features |= NodeResolutionFeatures.ResolutionModeAttributeFeatures; + features |= NodeResolutionFeatures.AllFeatures; } const moduleResolution = getEmitModuleResolutionKind(options); if (resolutionMode === ModuleKind.ESNext && (ModuleResolutionKind.Node16 <= moduleResolution && moduleResolution <= ModuleResolutionKind.NodeNext)) { @@ -588,7 +587,6 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup: false, candidateIsFromPackageJsonField: false, - overrideResolutionMode: resolutionMode, }; let resolved = primaryLookup(); let primary = true; @@ -729,17 +727,30 @@ function getNodeResolutionFeatures(options: CompilerOptions) { return features; } -/** @internal */ +/** + * @param overrideResolutionModeAttribute + * @internal + */ export function getConditions(options: CompilerOptions, esmMode?: boolean) { + const moduleResolution = getEmitModuleResolutionKind(options); + if (esmMode === undefined) { + if (moduleResolution === ModuleResolutionKind.Bundler) { + // bundler always uses `import` unless explicitly overridden + esmMode ??= moduleResolution === ModuleResolutionKind.Bundler; + } + else { + Debug.assert(moduleResolution !== ModuleResolutionKind.Node10, "getConditions should not be called for moduleResolution node10 without an explicit esmMode parameter"); + } + } // conditions are only used by the node16/nodenext/bundler resolvers - there's no priority order in the list, // it's essentially a set (priority is determined by object insertion order in the object we look at). - const conditions = esmMode || (esmMode !== false && getEmitModuleResolutionKind(options) === ModuleResolutionKind.Bundler) + const conditions = esmMode ? ["import"] : ["require"]; if (!options.noDtsResolution) { conditions.push("types"); } - if (getEmitModuleResolutionKind(options) !== ModuleResolutionKind.Bundler) { + if (moduleResolution !== ModuleResolutionKind.Bundler) { conditions.push("node"); } return concatenate(conditions, options.customConditions); @@ -1416,13 +1427,13 @@ export function resolveModuleName(moduleName: string, containingFile: string, co result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); break; case ModuleResolutionKind.Node10: - result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); + result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode === ModuleKind.ESNext) : undefined); break; case ModuleResolutionKind.Classic: result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); break; case ModuleResolutionKind.Bundler: - result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); + result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode === ModuleKind.ESNext) : undefined); break; default: return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`); @@ -1675,10 +1686,6 @@ export enum NodeResolutionFeatures { BundlerDefault = Imports | SelfName | Exports | ExportsPatternTrailers, - // features required to resolve `resolution-mode` overrides in - // type reference directives, import() types, and type-only imports - ResolutionModeAttributeFeatures = Imports | SelfName | Exports | ExportsPatternTrailers, - EsmMode = 1 << 5, } @@ -1708,7 +1715,7 @@ function nodeNextModuleNameResolver(moduleName: string, containingFile: string, ); } -function nodeNextModuleNameResolverWorker(features: NodeResolutionFeatures, moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations { +function nodeNextModuleNameResolverWorker(features: NodeResolutionFeatures, moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode, conditions?: string[]): ResolvedModuleWithFailedLookupLocations { const containingDirectory = getDirectoryPath(containingFile); // es module file or cjs-like input file, use a variant of the legacy cjs resolver that supports the selected modern features @@ -1717,7 +1724,7 @@ function nodeNextModuleNameResolverWorker(features: NodeResolutionFeatures, modu if (getResolveJsonModule(compilerOptions)) { extensions |= Extensions.Json; } - return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, /*overrideResolutionMode*/ undefined); + return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, conditions); } function tryResolveJSModuleWorker(moduleName: string, initialDir: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { @@ -1731,24 +1738,24 @@ function tryResolveJSModuleWorker(moduleName: string, initialDir: string, host: Extensions.JavaScript, /*isConfigLookup*/ false, /*redirectedReference*/ undefined, - /*overrideResolutionMode*/ undefined, + /*conditions*/ undefined, ); } export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; /** @internal */ -export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations; -export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations { +export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, conditions?: string[]): ResolvedModuleWithFailedLookupLocations; +export function bundlerModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, conditions?: string[]): ResolvedModuleWithFailedLookupLocations { const containingDirectory = getDirectoryPath(containingFile); let extensions = compilerOptions.noDtsResolution ? Extensions.ImplementationFiles : Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration; if (getResolveJsonModule(compilerOptions)) { extensions |= Extensions.Json; } - return nodeModuleNameResolverWorker(getNodeResolutionFeatures(compilerOptions), moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, resolutionMode); + return nodeModuleNameResolverWorker(getNodeResolutionFeatures(compilerOptions), moduleName, containingDirectory, compilerOptions, host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, conditions); } export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; -/** @internal */ export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode, lookupConfig?: boolean): ResolvedModuleWithFailedLookupLocations; // eslint-disable-line @typescript-eslint/unified-signatures -export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode, isConfigLookup?: boolean): ResolvedModuleWithFailedLookupLocations { +/** @internal */ export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, conditions?: string[], lookupConfig?: boolean): ResolvedModuleWithFailedLookupLocations; // eslint-disable-line @typescript-eslint/unified-signatures +export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, conditions?: string[], isConfigLookup?: boolean): ResolvedModuleWithFailedLookupLocations { let extensions; if (isConfigLookup) { extensions = Extensions.Json; @@ -1762,12 +1769,13 @@ export function nodeModuleNameResolver(moduleName: string, containingFile: strin ? Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration | Extensions.Json : Extensions.TypeScript | Extensions.JavaScript | Extensions.Declaration; } - return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference, resolutionMode); + + return nodeModuleNameResolverWorker(conditions ? NodeResolutionFeatures.AllFeatures : NodeResolutionFeatures.None, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference, conditions); } /** @internal */ export function nodeNextJsonConfigResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - return nodeModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, getDirectoryPath(containingFile), { moduleResolution: ModuleResolutionKind.NodeNext }, host, /*cache*/ undefined, Extensions.Json, /*isConfigLookup*/ true, /*redirectedReference*/ undefined, /*overrideResolutionMode*/ undefined); + return nodeModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, getDirectoryPath(containingFile), { moduleResolution: ModuleResolutionKind.NodeNext }, host, /*cache*/ undefined, Extensions.Json, /*isConfigLookup*/ true, /*redirectedReference*/ undefined); } function nodeModuleNameResolverWorker( @@ -1780,17 +1788,16 @@ function nodeModuleNameResolverWorker( extensions: Extensions, isConfigLookup: boolean, redirectedReference: ResolvedProjectReference | undefined, - overrideResolutionMode: ResolutionMode, + conditions?: readonly string[], ): ResolvedModuleWithFailedLookupLocations { const traceEnabled = isTraceEnabled(compilerOptions, host); const failedLookupLocations: string[] = []; const affectingLocations: string[] = []; - if (overrideResolutionMode) { - features |= NodeResolutionFeatures.ResolutionModeAttributeFeatures; + const moduleResolution = getEmitModuleResolutionKind(compilerOptions); + if (moduleResolution !== ModuleResolutionKind.Node10) { + conditions ??= getConditions(compilerOptions, moduleResolution === ModuleResolutionKind.Bundler ? undefined : !!(features & NodeResolutionFeatures.EsmMode)); } - const useImportCondition = !!(features & NodeResolutionFeatures.EsmMode) || (overrideResolutionMode ? overrideResolutionMode === ModuleKind.ESNext : undefined); - const conditions = getConditions(compilerOptions, useImportCondition); const diagnostics: Diagnostic[] = []; const state: ModuleResolutionState = { @@ -1806,15 +1813,13 @@ function nodeModuleNameResolverWorker( reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup, candidateIsFromPackageJsonField: false, - overrideResolutionMode, }; - - if (traceEnabled && moduleResolutionSupportsPackageJsonExportsAndImports(getEmitModuleResolutionKind(compilerOptions))) { + if (traceEnabled && moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) { trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & NodeResolutionFeatures.EsmMode ? "ESM" : "CJS", conditions.map(c => `'${c}'`).join(", ")); } let result; - if (getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.Node10) { + if (moduleResolution === ModuleResolutionKind.Node10) { const priorityExtensions = extensions & (Extensions.TypeScript | Extensions.Declaration); const secondaryExtensions = extensions & ~(Extensions.TypeScript | Extensions.Declaration); result = priorityExtensions && tryResolve(priorityExtensions, state) || @@ -1835,7 +1840,7 @@ function nodeModuleNameResolverWorker( && features & NodeResolutionFeatures.Exports && !isExternalModuleNameRelative(moduleName) && !extensionIsOk(Extensions.TypeScript | Extensions.Declaration, result.value.resolved.extension) - && conditions.includes("import") + && conditions?.includes("import") ) { traceIfEnabled(state, Diagnostics.Resolution_of_non_relative_name_failed_trying_with_modern_Node_resolution_features_disabled_to_see_if_npm_library_needs_configuration_update); const diagnosticState = { @@ -2316,7 +2321,6 @@ export function getTemporaryModuleResolutionState(packageJsonInfoCache: PackageJ reportDiagnostic: noop, isConfigLookup: false, candidateIsFromPackageJsonField: false, - overrideResolutionMode: undefined, }; } @@ -2686,7 +2690,7 @@ function getLoadModuleFromTargetImportOrExport(extensions: Extensions, state: Mo const combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath; traceIfEnabled(state, Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup); traceIfEnabled(state, Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/"); - const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, state.overrideResolutionMode); + const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, /*isConfigLookup*/ false, redirectedReference, state.conditions); return toSearchResult( result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, @@ -3169,7 +3173,6 @@ export function classicNameResolver(moduleName: string, containingFile: string, reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup: false, candidateIsFromPackageJsonField: false, - overrideResolutionMode: undefined, }; const resolved = tryResolve(Extensions.TypeScript | Extensions.Declaration) || @@ -3269,7 +3272,6 @@ export function loadModuleFromGlobalCache(moduleName: string, projectName: strin reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup: false, candidateIsFromPackageJsonField: false, - overrideResolutionMode: undefined, }; const resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.Declaration, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined); return createResolvedModuleWithFailedLookupLocations( diff --git a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.errors.txt b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.errors.txt deleted file mode 100644 index fcec678778db4..0000000000000 --- a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.errors.txt +++ /dev/null @@ -1,45 +0,0 @@ -/index.ts(1,23): error TS1452: 'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`. -/index.ts(1,23): error TS2688: Cannot find type definition file for 'pkg'. -/index.ts(2,23): error TS1452: 'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`. -/index.ts(2,23): error TS2688: Cannot find type definition file for 'pkg'. -/index.ts(3,1): error TS2304: Cannot find name 'foo'. -/index.ts(4,1): error TS2304: Cannot find name 'bar'. - - -==== /index.ts (6 errors) ==== - /// - ~~~ -!!! error TS1452: 'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`. - ~~~ -!!! error TS2688: Cannot find type definition file for 'pkg'. - /// - ~~~ -!!! error TS1452: 'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`. - ~~~ -!!! error TS2688: Cannot find type definition file for 'pkg'. - foo; // `resolution-mode` is an error in old resolution settings, which resolves is arbitrary - ~~~ -!!! error TS2304: Cannot find name 'foo'. - bar; - ~~~ -!!! error TS2304: Cannot find name 'bar'. - export {}; -==== /node_modules/pkg/package.json (0 errors) ==== - { - "name": "pkg", - "version": "0.0.1", - "exports": { - "import": "./import.js", - "require": "./require.js" - } - } -==== /node_modules/pkg/import.d.ts (0 errors) ==== - export {}; - declare global { - var foo: number; - } -==== /node_modules/pkg/require.d.ts (0 errors) ==== - export {}; - declare global { - var bar: number; - } \ No newline at end of file diff --git a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.symbols b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.symbols index 8a2edac1f389b..a7da6602add90 100644 --- a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.symbols +++ b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.symbols @@ -1,9 +1,28 @@ //// [tests/cases/conformance/node/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.ts] //// === /index.ts === - /// /// -foo; // `resolution-mode` is an error in old resolution settings, which resolves is arbitrary +foo; +>foo : Symbol(foo, Decl(import.d.ts, 2, 7)) + bar; +>bar : Symbol(bar, Decl(require.d.ts, 2, 7)) + +export {}; +=== /node_modules/pkg/import.d.ts === export {}; +declare global { +>global : Symbol(global, Decl(import.d.ts, 0, 10)) + + var foo: number; +>foo : Symbol(foo, Decl(import.d.ts, 2, 7)) +} +=== /node_modules/pkg/require.d.ts === +export {}; +declare global { +>global : Symbol(global, Decl(require.d.ts, 0, 10)) + + var bar: number; +>bar : Symbol(bar, Decl(require.d.ts, 2, 7)) +} diff --git a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.types b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.types index f3e89c2c89f14..79c8972776373 100644 --- a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.types +++ b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.types @@ -3,10 +3,26 @@ === /index.ts === /// /// -foo; // `resolution-mode` is an error in old resolution settings, which resolves is arbitrary ->foo : any +foo; +>foo : number bar; ->bar : any +>bar : number export {}; +=== /node_modules/pkg/import.d.ts === +export {}; +declare global { +>global : typeof global + + var foo: number; +>foo : number +} +=== /node_modules/pkg/require.d.ts === +export {}; +declare global { +>global : typeof global + + var bar: number; +>bar : number +} diff --git a/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt b/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt index cc6d3553d1735..1faa2b7574c83 100644 --- a/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt +++ b/tests/baselines/reference/resolutionModeTripleSlash2.errors.txt @@ -18,7 +18,9 @@ ~~~~~~ !!! error TS2304: Cannot find name 'MODULE'. SCRIPT; // ok - + function foo() { + return SCRIPT; + } ==== /node_modules/@types/foo/package.json (0 errors) ==== { "name": "@types/foo", diff --git a/tests/baselines/reference/resolutionModeTripleSlash2.js b/tests/baselines/reference/resolutionModeTripleSlash2.js index d55508989ee85..e30b6cf9158ac 100644 --- a/tests/baselines/reference/resolutionModeTripleSlash2.js +++ b/tests/baselines/reference/resolutionModeTripleSlash2.js @@ -28,8 +28,11 @@ declare global { /// MODULE; // error SCRIPT; // ok - +function foo() { + return SCRIPT; +} //// [app.d.ts] +declare function foo(): any; diff --git a/tests/cases/conformance/node/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.ts b/tests/cases/conformance/node/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.ts index 19e37f389adbb..96876c10b4809 100644 --- a/tests/cases/conformance/node/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.ts +++ b/tests/cases/conformance/node/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.ts @@ -23,6 +23,6 @@ declare global { // @filename: /index.ts /// /// -foo; // `resolution-mode` is an error in old resolution settings, which resolves is arbitrary +foo; bar; export {}; \ No newline at end of file From 94b33be23ecd70db064d5cf5b123d5acceb85a87 Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 19 Sep 2023 10:59:11 -0700 Subject: [PATCH 5/9] Fix type error --- src/compiler/moduleNameResolver.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index bae8747c37997..288a352c05b9b 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -1808,14 +1808,14 @@ function nodeModuleNameResolverWorker( affectingLocations, packageJsonInfoCache: cache, features, - conditions, + conditions: conditions ?? emptyArray, requestContainingDirectory: containingDirectory, reportDiagnostic: diag => void diagnostics.push(diag), isConfigLookup, candidateIsFromPackageJsonField: false, }; if (traceEnabled && moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) { - trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & NodeResolutionFeatures.EsmMode ? "ESM" : "CJS", conditions.map(c => `'${c}'`).join(", ")); + trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & NodeResolutionFeatures.EsmMode ? "ESM" : "CJS", state.conditions.map(c => `'${c}'`).join(", ")); } let result; From a4eb3350ee06d9e1d09135a9457990cfcd5e164b Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 19 Sep 2023 11:00:39 -0700 Subject: [PATCH 6/9] Update old baseline --- ...dulesTripleSlashReferenceModeOverrideOldResolutionError.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.js b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.js index 23956dcec3a63..e82a9a84d58bc 100644 --- a/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.js +++ b/tests/baselines/reference/nodeModulesTripleSlashReferenceModeOverrideOldResolutionError.js @@ -22,7 +22,7 @@ declare global { //// [index.ts] /// /// -foo; // `resolution-mode` is an error in old resolution settings, which resolves is arbitrary +foo; bar; export {}; @@ -31,5 +31,5 @@ export {}; Object.defineProperty(exports, "__esModule", { value: true }); /// /// -foo; // `resolution-mode` is an error in old resolution settings, which resolves is arbitrary +foo; bar; From 618ca6ad9830338eea55b4fedf7a3e7b3cc1ee28 Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 19 Sep 2023 11:08:13 -0700 Subject: [PATCH 7/9] Remove useless assertion --- src/compiler/moduleNameResolver.ts | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index 288a352c05b9b..c70a8e2153aea 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -738,8 +738,11 @@ export function getConditions(options: CompilerOptions, esmMode?: boolean) { // bundler always uses `import` unless explicitly overridden esmMode ??= moduleResolution === ModuleResolutionKind.Bundler; } - else { - Debug.assert(moduleResolution !== ModuleResolutionKind.Node10, "getConditions should not be called for moduleResolution node10 without an explicit esmMode parameter"); + else if (moduleResolution === ModuleResolutionKind.Node10) { + // node10 does not support package.json imports/exports without + // an explicit resolution-mode override on a type-only import + // (indicated by `esmMode` being set) + return []; } } // conditions are only used by the node16/nodenext/bundler resolvers - there's no priority order in the list, @@ -1795,9 +1798,12 @@ function nodeModuleNameResolverWorker( const failedLookupLocations: string[] = []; const affectingLocations: string[] = []; const moduleResolution = getEmitModuleResolutionKind(compilerOptions); - if (moduleResolution !== ModuleResolutionKind.Node10) { - conditions ??= getConditions(compilerOptions, moduleResolution === ModuleResolutionKind.Bundler ? undefined : !!(features & NodeResolutionFeatures.EsmMode)); - } + conditions ??= getConditions( + compilerOptions, + moduleResolution === ModuleResolutionKind.Bundler || moduleResolution === ModuleResolutionKind.Node10 + ? undefined + : !!(features & NodeResolutionFeatures.EsmMode), + ); const diagnostics: Diagnostic[] = []; const state: ModuleResolutionState = { From 6feb82a5b9881dd67b34bcdd08c2368513a7b82d Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 19 Sep 2023 14:16:24 -0700 Subject: [PATCH 8/9] Make parameter non-optional --- src/compiler/moduleNameResolver.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index c70a8e2153aea..2f7a9cf71d355 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -1778,7 +1778,7 @@ export function nodeModuleNameResolver(moduleName: string, containingFile: strin /** @internal */ export function nodeNextJsonConfigResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - return nodeModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, getDirectoryPath(containingFile), { moduleResolution: ModuleResolutionKind.NodeNext }, host, /*cache*/ undefined, Extensions.Json, /*isConfigLookup*/ true, /*redirectedReference*/ undefined); + return nodeModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, getDirectoryPath(containingFile), { moduleResolution: ModuleResolutionKind.NodeNext }, host, /*cache*/ undefined, Extensions.Json, /*isConfigLookup*/ true, /*redirectedReference*/ undefined, /*conditions*/ undefined); } function nodeModuleNameResolverWorker( @@ -1791,7 +1791,7 @@ function nodeModuleNameResolverWorker( extensions: Extensions, isConfigLookup: boolean, redirectedReference: ResolvedProjectReference | undefined, - conditions?: readonly string[], + conditions: readonly string[] | undefined, ): ResolvedModuleWithFailedLookupLocations { const traceEnabled = isTraceEnabled(compilerOptions, host); From f989f5a8b333abb74e6d9bd190900c1b43339758 Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 26 Sep 2023 13:54:13 -0700 Subject: [PATCH 9/9] Fix merge conflict resolution error --- src/compiler/checker.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 1b7f57a2ada1d..8a44d047ac3cc 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -39764,6 +39764,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function checkImportType(node: ImportTypeNode) { checkSourceElement(node.argument); + + if (node.attributes) { + getResolutionModeOverride(node.attributes, grammarErrorOnNode); + } checkTypeReferenceOrImport(node); }