Pick #62669, #62567, #62509 to tsgo-port

src/compiler/commandLineParser.ts

@@ -607,6 +607,7 @@ export const moduleOptionDeclaration: CommandLineOptionOfCustomType = {
         nodenext: ModuleKind.NodeNext,
         preserve: ModuleKind.Preserve,
     })),
+    deprecatedKeys: new Set(["none", "amd", "system", "umd"]),
     affectsSourceFile: true,
     affectsModuleResolution: true,
     affectsEmit: true,
@@ -1070,13 +1071,13 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
             nodenext: ModuleResolutionKind.NodeNext,
             bundler: ModuleResolutionKind.Bundler,
         })),
-        deprecatedKeys: new Set(["node"]),
+        deprecatedKeys: new Set(["node", "node10", "classic"]),
         affectsSourceFile: true,
         affectsModuleResolution: true,
         paramType: Diagnostics.STRATEGY,
         category: Diagnostics.Modules,
         description: Diagnostics.Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier,
-        defaultValueDescription: Diagnostics.module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node,
+        defaultValueDescription: Diagnostics.nodenext_if_module_is_nodenext_node16_if_module_is_node16_or_node18_otherwise_bundler,
     },
     {
         name: "baseUrl",
@@ -1149,7 +1150,7 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
         affectsBuildInfo: true,
         category: Diagnostics.Interop_Constraints,
         description: Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export,
-        defaultValueDescription: Diagnostics.module_system_or_esModuleInterop,
+        defaultValueDescription: true,
     },
     {
         name: "esModuleInterop",
@@ -1160,7 +1161,7 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
         showInSimplifiedHelpView: true,
         category: Diagnostics.Interop_Constraints,
         description: Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility,
-        defaultValueDescription: false,
+        defaultValueDescription: true,
     },
     {
         name: "preserveSymlinks",

src/compiler/diagnosticMessages.json

@@ -4717,6 +4717,10 @@
         "category": "Error",
         "code": 5110
     },
+    "Visit https://aka.ms/ts6 for migration information.": {
+        "category": "Message",
+        "code": 5111
+    },
 
     "Generates a sourcemap for each corresponding '.d.ts' file.": {
         "category": "Message",
@@ -6603,7 +6607,7 @@
         "category": "Message",
         "code": 6909
     },
-    "module === `AMD` or `UMD` or `System` or `ES6`, then `Classic`, Otherwise `Node`": {
+    "`nodenext` if `module` is `nodenext`; `node16` if `module` is `node16` or `node18`; otherwise, `bundler`.": {
         "category": "Message",
         "code": 69010
     },

src/compiler/program.ts

@@ -4446,8 +4446,8 @@ export function createProgram(_rootNamesOrOptions: readonly string[] | CreatePro
     function checkDeprecations(
         deprecatedIn: string,
         removedIn: string,
-        createDiagnostic: (name: string, value: string | undefined, useInstead: string | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) => void,
-        fn: (createDeprecatedDiagnostic: (name: string, value?: string, useInstead?: string) => void) => void,
+        createDiagnostic: (name: string, value: string | undefined, useInstead: string | undefined, related: DiagnosticMessage | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) => void,
+        fn: (createDeprecatedDiagnostic: (name: string, value?: string, useInstead?: string, related?: DiagnosticMessage) => void) => void,
     ) {
         const deprecatedInVersion = new Version(deprecatedIn);
         const removedInVersion = new Version(removedIn);
@@ -4458,36 +4458,44 @@ export function createProgram(_rootNamesOrOptions: readonly string[] | CreatePro
         const canBeSilenced = !mustBeRemoved && ignoreDeprecationsVersion.compareTo(deprecatedInVersion) === Comparison.LessThan;
 
         if (mustBeRemoved || canBeSilenced) {
-            fn((name, value, useInstead) => {
+            fn((name, value, useInstead, related) => {
                 if (mustBeRemoved) {
                     if (value === undefined) {
-                        createDiagnostic(name, value, useInstead, Diagnostics.Option_0_has_been_removed_Please_remove_it_from_your_configuration, name);
+                        createDiagnostic(name, value, useInstead, related, Diagnostics.Option_0_has_been_removed_Please_remove_it_from_your_configuration, name);
                     }
                     else {
-                        createDiagnostic(name, value, useInstead, Diagnostics.Option_0_1_has_been_removed_Please_remove_it_from_your_configuration, name, value);
+                        createDiagnostic(name, value, useInstead, related, Diagnostics.Option_0_1_has_been_removed_Please_remove_it_from_your_configuration, name, value);
                     }
                 }
                 else {
                     if (value === undefined) {
-                        createDiagnostic(name, value, useInstead, Diagnostics.Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error, name, removedIn, deprecatedIn);
+                        createDiagnostic(name, value, useInstead, related, Diagnostics.Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error, name, removedIn, deprecatedIn);
                     }
                     else {
-                        createDiagnostic(name, value, useInstead, Diagnostics.Option_0_1_is_deprecated_and_will_stop_functioning_in_TypeScript_2_Specify_compilerOption_ignoreDeprecations_Colon_3_to_silence_this_error, name, value, removedIn, deprecatedIn);
+                        createDiagnostic(name, value, useInstead, related, Diagnostics.Option_0_1_is_deprecated_and_will_stop_functioning_in_TypeScript_2_Specify_compilerOption_ignoreDeprecations_Colon_3_to_silence_this_error, name, value, removedIn, deprecatedIn);
                     }
                 }
             });
         }
     }
 
     function verifyDeprecatedCompilerOptions() {
-        function createDiagnostic(name: string, value: string | undefined, useInstead: string | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) {
+        function createDiagnostic(name: string, value: string | undefined, useInstead: string | undefined, related: DiagnosticMessage | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) {
             if (useInstead) {
-                const details = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Use_0_instead, useInstead);
+                let details = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Use_0_instead, useInstead);
+                if (related) {
+                    details = chainDiagnosticMessages(details, related);
+                }
                 const chain = chainDiagnosticMessages(details, message, ...args);
                 createDiagnosticForOption(/*onKey*/ !value, name, /*option2*/ undefined, chain);
             }
             else {
-                createDiagnosticForOption(/*onKey*/ !value, name, /*option2*/ undefined, message, ...args);
+                let details: DiagnosticMessageChain | undefined;
+                if (related) {
+                    details = chainDiagnosticMessages(/*details*/ undefined, related);
+                }
+                const chain = chainDiagnosticMessages(details, message, ...args);
+                createDiagnosticForOption(/*onKey*/ !value, name, /*option2*/ undefined, chain);
             }
         }
 
@@ -4526,13 +4534,28 @@ export function createProgram(_rootNamesOrOptions: readonly string[] | CreatePro
 
         checkDeprecations("6.0", "7.0", createDiagnostic, createDeprecatedDiagnostic => {
             if (options.moduleResolution === ModuleResolutionKind.Node10) {
-                createDeprecatedDiagnostic("moduleResolution", "node10");
+                createDeprecatedDiagnostic("moduleResolution", "node10", /*useInstead*/ undefined, Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashts6_for_migration_information);
+            }
+            if (options.moduleResolution === ModuleResolutionKind.Classic) {
+                createDeprecatedDiagnostic("moduleResolution", "classic");
+            }
+            if (options.baseUrl !== undefined) {
+                createDeprecatedDiagnostic("baseUrl", /*value*/ undefined, /*useInstead*/ undefined, Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashts6_for_migration_information);
+            }
+            if (options.esModuleInterop === false) {
+                createDeprecatedDiagnostic("esModuleInterop", "false", /*useInstead*/ undefined, /*related*/ undefined);
+            }
+            if (options.allowSyntheticDefaultImports === false) {
+                createDeprecatedDiagnostic("allowSyntheticDefaultImports", "false", /*useInstead*/ undefined, /*related*/ undefined);
+            }
+            if (options.module === ModuleKind.None || options.module === ModuleKind.AMD || options.module === ModuleKind.UMD || options.module === ModuleKind.System) {
+                createDeprecatedDiagnostic("module", ModuleKind[options.module]);
             }
         });
     }
 
     function verifyDeprecatedProjectReference(ref: ProjectReference, parentFile: JsonSourceFile | undefined, index: number) {
-        function createDiagnostic(_name: string, _value: string | undefined, _useInstead: string | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) {
+        function createDiagnostic(_name: string, _value: string | undefined, _useInstead: string | undefined, _related: DiagnosticMessage | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) {
             createDiagnosticForReference(parentFile, index, message, ...args);
         }
 

src/compiler/types.ts

@@ -7331,6 +7331,7 @@ export function diagnosticCategoryName(d: { category: DiagnosticCategory; }, low
 }
 
 export enum ModuleResolutionKind {
+    /** @deprecated */
     Classic = 1,
     /**
      * @deprecated
@@ -7418,6 +7419,7 @@ export interface CompilerOptions {
     allowUnreachableCode?: boolean;
     allowUnusedLabels?: boolean;
     alwaysStrict?: boolean; // Always combine with strict property
+    /** @deprecated */
     baseUrl?: string;
     /**
      * An error if set - this should only go through the -b pipeline and not actually be observed
@@ -7593,10 +7595,14 @@ export interface TypeAcquisition {
 }
 
 export enum ModuleKind {
+    /** @deprecated */
     None = 0,
     CommonJS = 1,
+    /** @deprecated */
     AMD = 2,
+    /** @deprecated */
     UMD = 3,
+    /** @deprecated */
     System = 4,
 
     // NOTE: ES module kinds should be contiguous to more easily check whether a module kind is *any* ES module kind.

src/compiler/utilities.ts

@@ -8985,27 +8985,23 @@ const _computedOptions = createComputedCompilerOptions({
     moduleResolution: {
         dependencies: ["module", "target"],
         computeValue: (compilerOptions): ModuleResolutionKind => {
-            let moduleResolution = compilerOptions.moduleResolution;
-            if (moduleResolution === undefined) {
-                switch (_computedOptions.module.computeValue(compilerOptions)) {
-                    case ModuleKind.Node16:
-                    case ModuleKind.Node18:
-                    case ModuleKind.Node20:
-                        moduleResolution = ModuleResolutionKind.Node16;
-                        break;
-                    case ModuleKind.NodeNext:
-                        moduleResolution = ModuleResolutionKind.NodeNext;
-                        break;
-                    case ModuleKind.CommonJS:
-                    case ModuleKind.Preserve:
-                        moduleResolution = ModuleResolutionKind.Bundler;
-                        break;
-                    default:
-                        moduleResolution = ModuleResolutionKind.Classic;
-                        break;
-                }
+            if (compilerOptions.moduleResolution !== undefined) {
+                return compilerOptions.moduleResolution;
             }
-            return moduleResolution;
+            const moduleKind = _computedOptions.module.computeValue(compilerOptions);
+            switch (moduleKind) {
+                case ModuleKind.None:
+                case ModuleKind.AMD:
+                case ModuleKind.UMD:
+                case ModuleKind.System:
+                    return ModuleResolutionKind.Classic;
+                case ModuleKind.NodeNext:
+                    return ModuleResolutionKind.NodeNext;
+            }
+            if (ModuleKind.Node16 <= moduleKind && moduleKind < ModuleKind.NodeNext) {
+                return ModuleResolutionKind.Node16;
+            }
+            return ModuleResolutionKind.Bundler;
         },
     },
     moduleDetection: {
@@ -9027,35 +9023,25 @@ const _computedOptions = createComputedCompilerOptions({
         },
     },
     esModuleInterop: {
-        dependencies: ["module", "target"],
+        dependencies: [],
         computeValue: (compilerOptions): boolean => {
             if (compilerOptions.esModuleInterop !== undefined) {
                 return compilerOptions.esModuleInterop;
             }
-            switch (_computedOptions.module.computeValue(compilerOptions)) {
-                case ModuleKind.Node16:
-                case ModuleKind.Node18:
-                case ModuleKind.Node20:
-                case ModuleKind.NodeNext:
-                case ModuleKind.Preserve:
-                    return true;
-            }
-            return false;
+            return true;
         },
     },
     allowSyntheticDefaultImports: {
-        dependencies: ["module", "target", "moduleResolution"],
+        dependencies: [],
         computeValue: (compilerOptions): boolean => {
             if (compilerOptions.allowSyntheticDefaultImports !== undefined) {
                 return compilerOptions.allowSyntheticDefaultImports;
             }
-            return _computedOptions.esModuleInterop.computeValue(compilerOptions)
-                || _computedOptions.module.computeValue(compilerOptions) === ModuleKind.System
-                || _computedOptions.moduleResolution.computeValue(compilerOptions) === ModuleResolutionKind.Bundler;
+            return true;
         },
     },
     resolvePackageJsonExports: {
-        dependencies: ["moduleResolution"],
+        dependencies: ["moduleResolution", "module", "target"],
         computeValue: (compilerOptions): boolean => {
             const moduleResolution = _computedOptions.moduleResolution.computeValue(compilerOptions);
             if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
@@ -9074,7 +9060,7 @@ const _computedOptions = createComputedCompilerOptions({
         },
     },
     resolvePackageJsonImports: {
-        dependencies: ["moduleResolution", "resolvePackageJsonExports"],
+        dependencies: ["moduleResolution", "resolvePackageJsonExports", "module", "target"],
         computeValue: (compilerOptions): boolean => {
             const moduleResolution = _computedOptions.moduleResolution.computeValue(compilerOptions);
             if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {

src/services/completions.ts

@@ -482,7 +482,7 @@ export const enum SymbolOriginInfoKind {
     ComputedPropertyName = 1 << 9,
 
     SymbolMemberNoExport = SymbolMember,
-    SymbolMemberExport   = SymbolMember | Export,
+    SymbolMemberExport   = SymbolMember | ResolvedExport,
 }
 
 /** @internal */
@@ -536,7 +536,7 @@ function originIsExport(origin: SymbolOriginInfo | undefined): origin is SymbolO
 }
 
 function originIsResolvedExport(origin: SymbolOriginInfo | undefined): origin is SymbolOriginInfoResolvedExport {
-    return !!(origin && origin.kind === SymbolOriginInfoKind.ResolvedExport);
+    return !!(origin && origin.kind & SymbolOriginInfoKind.ResolvedExport);
 }
 
 function originIncludesSymbolName(origin: SymbolOriginInfo | undefined): origin is SymbolOriginInfoExport | SymbolOriginInfoResolvedExport | SymbolOriginInfoComputedPropertyName {
@@ -2621,12 +2621,12 @@ function isRecommendedCompletionMatch(localSymbol: Symbol, recommendedCompletion
 }
 
 function getSourceFromOrigin(origin: SymbolOriginInfo | undefined): string | undefined {
-    if (originIsExport(origin)) {
-        return stripQuotes(origin.moduleSymbol.name);
-    }
     if (originIsResolvedExport(origin)) {
         return origin.moduleSpecifier;
     }
+    if (originIsExport(origin)) {
+        return stripQuotes(origin.moduleSymbol.name);
+    }
     if (origin?.kind === SymbolOriginInfoKind.ThisType) {
         return CompletionSource.ThisProperty;
     }

src/testRunner/unittests/evaluation/awaitUsingDeclarations.ts

@@ -1445,7 +1445,7 @@ describe("unittests:: evaluation:: awaitUsingDeclarations", () => {
         export const y = 2;
         output.push("after export y");
         `,
-            { target: ts.ScriptTarget.ES2018, module: ts.ModuleKind.System },
+            { target: ts.ScriptTarget.ES2018, module: ts.ModuleKind.System, ignoreDeprecations: "6.0" },
         );
 
         assert.strictEqual(x, 1);

src/testRunner/unittests/evaluation/updateExpressionInModule.ts

@@ -31,7 +31,7 @@ describe("unittests:: evaluation:: updateExpressionInModule", () => {
             },
             rootFiles: ["/.src/main.ts"],
             main: "/.src/main.ts",
-        }, { module: ts.ModuleKind.System });
+        }, { module: ts.ModuleKind.System, ignoreDeprecations: "6.0" });
         assert.equal(result.a, 2);
         assert.equal(result.b, 2);
     });
@@ -67,7 +67,7 @@ describe("unittests:: evaluation:: updateExpressionInModule", () => {
                 rootFiles: ["/.src/main.ts"],
                 main: "/.src/main.ts",
             },
-            { module: ts.ModuleKind.System },
+            { module: ts.ModuleKind.System, ignoreDeprecations: "6.0" },
             { BigInt },
         );
         assert.equal(result.a, BigInt(2));
@@ -99,7 +99,7 @@ describe("unittests:: evaluation:: updateExpressionInModule", () => {
             },
             rootFiles: ["/.src/main.ts"],
             main: "/.src/main.ts",
-        }, { module: ts.ModuleKind.System });
+        }, { module: ts.ModuleKind.System, ignoreDeprecations: "6.0" });
         assert.equal(result.a, 2);
         assert.equal(result.b, 1);
     });
@@ -135,7 +135,7 @@ describe("unittests:: evaluation:: updateExpressionInModule", () => {
                 rootFiles: ["/.src/main.ts"],
                 main: "/.src/main.ts",
             },
-            { module: ts.ModuleKind.System },
+            { module: ts.ModuleKind.System, ignoreDeprecations: "6.0" },
             { BigInt },
         );
         assert.equal(result.a, BigInt(2));

src/testRunner/unittests/evaluation/usingDeclarations.ts

@@ -1594,7 +1594,7 @@ describe("unittests:: evaluation:: usingDeclarations", () => {
         export const y = 2;
         output.push("after export y");
         `,
-            { target: ts.ScriptTarget.ES2018, module: ts.ModuleKind.AMD },
+            { target: ts.ScriptTarget.ES2018, module: ts.ModuleKind.AMD, ignoreDeprecations: "6.0" },
         );
 
         assert.strictEqual(x, 1);
@@ -1624,7 +1624,7 @@ describe("unittests:: evaluation:: usingDeclarations", () => {
         export const y = 2;
         output.push("after export y");
         `,
-            { target: ts.ScriptTarget.ES2018, module: ts.ModuleKind.System },
+            { target: ts.ScriptTarget.ES2018, module: ts.ModuleKind.System, ignoreDeprecations: "6.0" },
         );
 
         assert.strictEqual(x, 1);