feat(51000): add ignoreDeprecations option

Author: a-tarasyuk

src/compiler/commandLineParser.ts

@@ -1352,6 +1352,15 @@ namespace ts {
             description: Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
             category: Diagnostics.Language_and_Environment,
             defaultValueDescription: Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules,
+        },
+        {
+            name: "ignoreDeprecations",
+            type: new Map(getEntries({
+                [DeprecationPhaseToVersionMap[DeprecationPhase.Phase1]]: DeprecationPhase.Phase1,
+                [DeprecationPhaseToVersionMap[DeprecationPhase.Phase2]]: DeprecationPhase.Phase2,
+                [DeprecationPhaseToVersionMap[DeprecationPhase.Phase3]]: DeprecationPhase.Phase3,
+            })),
+            defaultValueDescription: undefined,
         }
     ];
 

src/compiler/diagnosticMessages.json

@@ -4221,6 +4221,18 @@
         "category": "Error",
         "code": 5095
     },
+    "Flag '{0}' is deprecated and will stop functioning in TypeScript {1}. Specify 'ignoreDeprecations: \"{2}\"' to silence this error.": {
+        "category": "Error",
+        "code": 5096
+    },
+    "Flag '{0}' is deprecated, please remove it from your configuration.": {
+        "category": "Error",
+        "code": 5097
+    },
+    "Invalid value for '--ignoreDeprecations'.": {
+        "category": "Error",
+        "code": 5098
+    },
 
     "Generates a sourcemap for each corresponding '.d.ts' file.": {
         "category": "Message",

src/compiler/program.ts

@@ -1021,12 +1021,11 @@ namespace ts {
      * @param configFileParsingDiagnostics - error during config file parsing
      * @returns A 'Program' object.
      */
-    export function createProgram(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[]): Program;
-    export function createProgram(rootNamesOrOptions: readonly string[] | CreateProgramOptions, _options?: CompilerOptions, _host?: CompilerHost, _oldProgram?: Program, _configFileParsingDiagnostics?: readonly Diagnostic[]): Program {
+    export function createProgram(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[], typeScriptVersion?: string): Program;
+    export function createProgram(rootNamesOrOptions: readonly string[] | CreateProgramOptions, _options?: CompilerOptions, _host?: CompilerHost, _oldProgram?: Program, _configFileParsingDiagnostics?: readonly Diagnostic[], typeScriptVersion?: string): Program {
         const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options!, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; // TODO: GH#18217
         const { rootNames, options, configFileParsingDiagnostics, projectReferences } = createProgramOptions;
         let { oldProgram } = createProgramOptions;
-
         let processingDefaultLibFiles: SourceFile[] | undefined;
         let processingOtherFiles: SourceFile[] | undefined;
         let files: SourceFile[];
@@ -1073,6 +1072,9 @@ namespace ts {
         const supportedExtensions = getSupportedExtensions(options);
         const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
 
+        let _typeScriptVersion: Version | undefined;
+        const _ignoreDeprecations = new Map<DeprecationPhase, Version>();
+
         // Map storing if there is emit blocking diagnostics for given input
         const hasEmitBlockingDiagnostics = new Map<string, boolean>();
         let _compilerOptionsObjectLiteralSyntax: ObjectLiteralExpression | false | undefined;
@@ -3397,6 +3399,7 @@ namespace ts {
             if (options.strictPropertyInitialization && !getStrictOptionValue(options, "strictNullChecks")) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
             }
+
             if (options.exactOptionalPropertyTypes && !getStrictOptionValue(options, "strictNullChecks")) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks");
             }
@@ -3439,6 +3442,7 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
             }
 
+            verifyDeprecatedCompilerOptions();
             verifyProjectReferences();
 
             // List of collected files is complete; validate exhautiveness if this is a project with a file list
@@ -3701,6 +3705,55 @@ namespace ts {
             }
         }
 
+        function verifyDeprecatedCompilerOptions() {
+            const version = isString(typeScriptVersion) && typeScriptVersion ? new Version(typeScriptVersion) : getTypeScriptVersion();
+            if (options.ignoreDeprecations) {
+                const ignoreDeprecationsVersion = getIgnoreDeprecationsVersion(options.ignoreDeprecations);
+                if (ignoreDeprecationsVersion.compareTo(version) === Comparison.LessThan) {
+                    createOptionValueDiagnostic("ignoreDeprecations", Diagnostics.Invalid_value_for_ignoreDeprecations);
+                }
+                if (ignoreDeprecationsVersion.compareTo(version) >= 0) {
+                    return;
+                }
+            }
+            if (options.target === ScriptTarget.ES3) {
+                createDeprecatedDiagnosticForOption(version, "target", "ES3");
+            }
+            if (options.noImplicitUseStrict) {
+                createDeprecatedDiagnosticForOption(version, "noImplicitUseStrict");
+            }
+            if (options.keyofStringsOnly) {
+                createDeprecatedDiagnosticForOption(version, "keyofStringsOnly");
+            }
+            if (options.suppressExcessPropertyErrors) {
+                createDeprecatedDiagnosticForOption(version, "suppressExcessPropertyErrors");
+            }
+            if (options.suppressImplicitAnyIndexErrors) {
+                createDeprecatedDiagnosticForOption(version, "suppressImplicitAnyIndexErrors");
+            }
+            if (options.noStrictGenericChecks) {
+                createDeprecatedDiagnosticForOption(version, "noStrictGenericChecks");
+            }
+            if (options.charset) {
+                createDeprecatedDiagnosticForOption(version, "charset");
+            }
+            if (options.out) {
+                createDeprecatedDiagnosticForOption(version, "out");
+            }
+        }
+
+        function createDeprecatedDiagnosticForOption(version: Version, name: string, value?: string) {
+            if (version.compareTo(getIgnoreDeprecationsVersion(DeprecationPhase.Phase3)) === Comparison.EqualTo) {
+                createDiagnosticForOption(/*onKey*/ !value, name, /*option2*/ undefined, Diagnostics.Flag_0_is_deprecated_please_remove_it_from_your_configuration, value || name);
+            }
+            else {
+                const { major, minor } = version;
+                const nextPhase = version.compareTo(getIgnoreDeprecationsVersion(DeprecationPhase.Phase2)) === Comparison.EqualTo ? DeprecationPhase.Phase3 : DeprecationPhase.Phase2;
+                createDiagnosticForOption(/*onKey*/ !value, name, /*option2*/ undefined,
+                    Diagnostics.Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_ignoreDeprecations_Colon_2_to_silence_this_error, value || name, DeprecationPhaseToVersionMap[nextPhase], `${major}.${minor}`);
+            }
+        }
+
         function createDiagnosticExplainingFile(file: SourceFile | undefined, fileProcessingReason: FileIncludeReason | undefined, diagnostic: DiagnosticMessage, args: (string | number | undefined)[] | undefined): Diagnostic {
             let fileIncludeReasons: DiagnosticMessageChain[] | undefined;
             let relatedInfo: Diagnostic[] | undefined;
@@ -3972,6 +4025,21 @@ namespace ts {
             return _compilerOptionsObjectLiteralSyntax || undefined;
         }
 
+        function getTypeScriptVersion() {
+            if (_typeScriptVersion === undefined) {
+                _typeScriptVersion = new Version(versionMajorMinor);
+            }
+            return _typeScriptVersion;
+        }
+
+        function getIgnoreDeprecationsVersion(phase: DeprecationPhase) {
+            let version = _ignoreDeprecations.get(phase);
+            if (version === undefined) {
+                _ignoreDeprecations.set(phase, version = new Version(DeprecationPhaseToVersionMap[phase]));
+            }
+            return version;
+        }
+
         function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral: ObjectLiteralExpression, onKey: boolean, key1: string, key2: string | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): boolean {
             const props = getPropertyAssignment(objectLiteral, key1, key2);
             for (const prop of props) {

src/compiler/types.ts

@@ -6582,6 +6582,7 @@ namespace ts {
         /*@internal*/generateCpuProfile?: string;
         /*@internal*/generateTrace?: string;
         /*@internal*/help?: boolean;
+        ignoreDeprecations?: DeprecationPhase;
         importHelpers?: boolean;
         importsNotUsedAsValues?: ImportsNotUsedAsValues;
         /*@internal*/init?: boolean;
@@ -6740,6 +6741,19 @@ namespace ts {
         LineFeed = 1
     }
 
+    export const enum DeprecationPhase {
+        Phase1 = 1,
+        Phase2 = 2,
+        Phase3 = 3,
+    }
+
+    /* @internal */
+    export const DeprecationPhaseToVersionMap = {
+        [DeprecationPhase.Phase1]: "5.0",
+        [DeprecationPhase.Phase2]: "5.5",
+        [DeprecationPhase.Phase3]: "6.0",
+    };
+
     export interface LineAndCharacter {
         /** 0-based. */
         line: number;

src/harness/compilerImpl.ts

@@ -233,7 +233,7 @@ namespace compiler {
         }
     }
 
-    export function compileFiles(host: fakes.CompilerHost, rootFiles: string[] | undefined, compilerOptions: ts.CompilerOptions): CompilationResult {
+    export function compileFiles(host: fakes.CompilerHost, rootFiles: string[] | undefined, compilerOptions: ts.CompilerOptions, typeScriptVersion?: string): CompilationResult {
         if (compilerOptions.project || !rootFiles || rootFiles.length === 0) {
             const project = readProject(host.parseConfigHost, compilerOptions.project, compilerOptions);
             if (project) {
@@ -258,10 +258,10 @@ namespace compiler {
         // and if the test is running `skipLibCheck` - an indicator that we want the tets to run quickly - skip the before/after error comparison, too
         const skipErrorComparison = ts.length(rootFiles) >= 100 || (!!compilerOptions.skipLibCheck && !!compilerOptions.declaration);
 
-        const preProgram = !skipErrorComparison ? ts.createProgram(rootFiles || [], { ...compilerOptions, configFile: compilerOptions.configFile, traceResolution: false }, host) : undefined;
+        const preProgram = !skipErrorComparison ? ts.createProgram(rootFiles || [], { ...compilerOptions, configFile: compilerOptions.configFile, traceResolution: false }, host, /*oldProgram*/ undefined, /*configFileParsingDiagnostics*/ undefined, typeScriptVersion) : undefined;
         const preErrors = preProgram && ts.getPreEmitDiagnostics(preProgram);
 
-        const program = ts.createProgram(rootFiles || [], compilerOptions, host);
+        const program = ts.createProgram(rootFiles || [], compilerOptions, host, /*oldProgram*/ undefined, /*configFileParsingDiagnostics*/ undefined, typeScriptVersion);
         const emitResult = program.emit();
         const postErrors = ts.getPreEmitDiagnostics(program);
         const longerErrors = ts.length(preErrors) > postErrors.length ? preErrors : postErrors;

src/harness/harnessIO.ts

@@ -338,6 +338,9 @@ namespace Harness {
                     if (value === undefined) {
                         throw new Error(`Cannot have undefined value for compiler option '${name}'.`);
                     }
+                    if (name === "typeScriptVersion") {
+                        continue;
+                    }
                     const option = getCommandLineOption(name);
                     if (option) {
                         const errors: ts.Diagnostic[] = [];
@@ -399,17 +402,21 @@ namespace Harness {
                 currentDirectory = vfs.srcFolder;
             }
 
+            let typeScriptVersion: string | undefined;
+
             // Parse settings
             if (harnessSettings) {
                 setCompilerOptionsFromHarnessSetting(harnessSettings, options);
+                if (ts.isString(harnessSettings.typeScriptVersion) && harnessSettings.typeScriptVersion) {
+                    typeScriptVersion = harnessSettings.typeScriptVersion;
+                }
             }
             if (options.rootDirs) {
                 options.rootDirs = ts.map(options.rootDirs, d => ts.getNormalizedAbsolutePath(d, currentDirectory));
             }
 
             const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : true;
             const programFileNames = inputFiles.map(file => file.unitName).filter(fileName => !ts.fileExtensionIs(fileName, ts.Extension.Json));
-
             // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
             // Treat them as library files, so include them in build, but not in baselines.
             if (options.includeBuiltFile) {
@@ -429,7 +436,7 @@ namespace Harness {
                 fs.apply(symlinks);
             }
             const host = new fakes.CompilerHost(fs, options);
-            const result = compiler.compileFiles(host, programFileNames, options);
+            const result = compiler.compileFiles(host, programFileNames, options, typeScriptVersion);
             result.symlinks = symlinks;
             return result;
         }

tests/baselines/reference/2dArrays.errors.txt

@@ -0,0 +1,20 @@
+error TS5096: Flag 'ES3' is deprecated and will stop functioning in TypeScript 5.5. Specify 'ignoreDeprecations: "5.0"' to silence this error.
+
+
+!!! error TS5096: Flag 'ES3' is deprecated and will stop functioning in TypeScript 5.5. Specify 'ignoreDeprecations: "5.0"' to silence this error.
+==== tests/cases/compiler/2dArrays.ts (0 errors) ====
+    class Cell {
+    }
+    
+    class Ship {
+        isSunk: boolean;
+    }
+    
+    class Board {
+        ships: Ship[];
+        cells: Cell[];
+    
+        private allShipsSunk() {
+            return this.ships.every(function (val) { return val.isSunk; });
+        }    
+    }

tests/baselines/reference/APISample_Watch.errors.txt

@@ -0,0 +1,86 @@
+error TS5096: Flag 'ES3' is deprecated and will stop functioning in TypeScript 5.5. Specify 'ignoreDeprecations: "5.0"' to silence this error.
+
+
+!!! error TS5096: Flag 'ES3' is deprecated and will stop functioning in TypeScript 5.5. Specify 'ignoreDeprecations: "5.0"' to silence this error.
+==== tests/cases/compiler/APISample_Watch.ts (0 errors) ====
+    /*
+     * Note: This test is a public API sample. The sample sources can be found
+     *       at: https://github.com/Microsoft/TypeScript-wiki/blob/master/Using-the-Compiler-API.md#writing-an-incremental-program-watcher
+     *       Please log a "breaking change" issue for any API breaking change affecting this issue
+     */
+    
+    declare var process: any;
+    declare var console: any;
+    declare var os: any;
+    
+    import ts = require("typescript");
+    
+    const formatHost: ts.FormatDiagnosticsHost = {
+        getCanonicalFileName: path => path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    }
+    
+    function watchMain() {
+        const configPath = ts.findConfigFile(/*searchPath*/ "./", ts.sys.fileExists, "tsconfig.json");
+        if (!configPath) {
+            throw new Error("Could not find a valid 'tsconfig.json'.");
+        }
+    
+        // TypeScript can use several different program creation "strategies":
+        //  * ts.createEmitAndSemanticDiagnosticsBuilderProgram,
+        //  * ts.createSemanticDiagnosticsBuilderProgram
+        //  * ts.createAbstractBuilder
+        // The first two produce "builder programs". These use an incremental strategy to only re-check and emit files whose
+        // contents may have changed, or whose dependencies may have changes which may impact change the result of prior type-check and emit.
+        // The last uses an ordinary program which does a full type check after every change.
+        // Between `createEmitAndSemanticDiagnosticsBuilderProgram` and `createSemanticDiagnosticsBuilderProgram`, the only difference is emit.
+        // For pure type-checking scenarios, or when another tool/process handles emit, using `createSemanticDiagnosticsBuilderProgram` may be more desirable.
+    
+        // Note that there is another overload for `createWatchCompilerHost` that takes a set of root files.
+        const host = ts.createWatchCompilerHost(configPath, {}, ts.sys,
+            ts.createSemanticDiagnosticsBuilderProgram,
+            reportDiagnostic,
+            reportWatchStatusChanged,
+        );
+    
+        // You can technically override any given hook on the host, though you probably don't need to.
+        // Note that we're assuming `origCreateProgram` and `origPostProgramCreate` doesn't use `this` at all.
+        const origCreateProgram = host.createProgram;
+        host.createProgram = (rootNames: ReadonlyArray<string>, options, host, oldProgram) => {
+            console.log("** We're about to create the program! **");
+            return origCreateProgram(rootNames, options, host, oldProgram);
+        }
+        const origPostProgramCreate = host.afterProgramCreate;
+    
+        host.afterProgramCreate = program => {
+            console.log("** We finished making the program! **");
+            origPostProgramCreate!(program);
+        };
+    
+        // `createWatchProgram` creates an initial program, watches files, and updates the program over time.
+        ts.createWatchProgram(host);
+    }
+    
+    function reportDiagnostic(diagnostic: ts.Diagnostic) {
+        console.error("Error", diagnostic.code, ":",
+            ts.flattenDiagnosticMessageText(diagnostic.messageText, formatHost.getNewLine())
+        );
+    }
+    
+    /**
+     * Prints a diagnostic every time the watch status changes.
+     * This is mainly for messages like "Starting compilation" or "Compilation completed".
+     */
+    function reportWatchStatusChanged(diagnostic: ts.Diagnostic) {
+        console.info(ts.formatDiagnostic(diagnostic, formatHost));
+    }
+    
+    watchMain();
+    
+==== tests/cases/compiler/node_modules/typescript/package.json (0 errors) ====
+    {
+        "name": "typescript",
+        "types": "/.ts/typescript.d.ts"
+    }
+