Add noCheck API option

src/compiler/checker.ts

@@ -8792,6 +8792,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
 
             function serializeSymbol(symbol: Symbol, isPrivate: boolean, propertyAsAlias: boolean): void {
+                void getPropertiesOfType(getTypeOfSymbol(symbol)); // resolve symbol's type and properties, which should trigger any required merges
                 // cache visited list based on merged symbol, since we want to use the unmerged top-level symbol, but
                 // still skip reserializing it if we encounter the merged product later on
                 const visitedSym = getMergedSymbol(symbol);
@@ -48846,6 +48847,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 if (!sym) {
                     return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
                 }
+                resolveExternalModuleSymbol(sym); // ensures cjs export assignment is setup
                 return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
             },
             isImportRequiredByAugmentation,

src/compiler/commandLineParser.ts

@@ -772,6 +772,20 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
         defaultValueDescription: false,
         description: Diagnostics.Disable_emitting_comments,
     },
+    {
+        name: "noCheck",
+        type: "boolean",
+        showInSimplifiedHelpView: false,
+        category: Diagnostics.Compiler_Diagnostics,
+        description: Diagnostics.Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported,
+        transpileOptionValue: undefined,
+        defaultValueDescription: false,
+        affectsSemanticDiagnostics: true,
+        affectsBuildInfo: true,
+        extraValidation() {
+            return [Diagnostics.Unknown_compiler_option_0, "noCheck"];
+        },
+    },
     {
         name: "noEmit",
         type: "boolean",

src/compiler/diagnosticMessages.json

@@ -6388,6 +6388,10 @@
         "category": "Message",
         "code": 6804
     },
+    "Disable full type checking (only critical parse and emit errors will be reported).": {
+        "category": "Message",
+        "code": 6805
+    },
 
     "one of:": {
         "category": "Message",

src/compiler/emitter.ts

@@ -848,8 +848,8 @@ export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFi
         const filesForEmit = forceDtsEmit ? sourceFiles : filter(sourceFiles, isSourceFileNotJson);
         // Setup and perform the transformation to retrieve declarations from the input files
         const inputListOrBundle = compilerOptions.outFile ? [factory.createBundle(filesForEmit)] : filesForEmit;
-        if (emitOnly && !getEmitDeclarations(compilerOptions)) {
-            // Checker wont collect the linked aliases since thats only done when declaration is enabled.
+        if ((emitOnly && !getEmitDeclarations(compilerOptions)) || compilerOptions.noCheck) {
+            // Checker wont collect the linked aliases since thats only done when declaration is enabled and checking is performed.
             // Do that here when emitting only dts files
             filesForEmit.forEach(collectLinkedAliases);
         }

src/compiler/program.ts

@@ -4424,6 +4424,15 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             }
         }
 
+        if (options.noCheck) {
+            if (options.noEmit) {
+                createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noCheck", "noEmit");
+            }
+            if (!options.emitDeclarationOnly) {
+                createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "noCheck", "emitDeclarationOnly");
+            }
+        }
+
         if (
             options.emitDecoratorMetadata &&
             !options.experimentalDecorators

src/compiler/types.ts

@@ -7270,6 +7270,7 @@ export interface CompilerOptions {
     moduleDetection?: ModuleDetectionKind;
     newLine?: NewLineKind;
     noEmit?: boolean;
+    /** @internal */ noCheck?: boolean;
     /** @internal */ noEmitForJsFiles?: boolean;
     noEmitHelpers?: boolean;
     noEmitOnError?: boolean;

src/compiler/utilities.ts

@@ -9967,6 +9967,7 @@ export function skipTypeChecking(sourceFile: SourceFile, options: CompilerOption
     // '/// <reference no-default-lib="true"/>' directive.
     return (options.skipLibCheck && sourceFile.isDeclarationFile ||
         options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib) ||
+        options.noCheck ||
         host.isSourceOfProjectReferenceRedirect(sourceFile.fileName);
 }
 

src/harness/harnessIO.ts

@@ -303,6 +303,7 @@ export namespace Compiler {
         { name: "noTypesAndSymbols", type: "boolean", defaultValueDescription: false },
         // Emitted js baseline will print full paths for every output file
         { name: "fullEmitPaths", type: "boolean", defaultValueDescription: false },
+        { name: "noCheck", type: "boolean", defaultValueDescription: false },
         { name: "reportDiagnostics", type: "boolean", defaultValueDescription: false }, // used to enable error collection in `transpile` baselines
     ];
 
@@ -371,6 +372,8 @@ export namespace Compiler {
         fileOptions?: any;
     }
 
+    export type CompileFilesResult = compiler.CompilationResult & { repeat(newOptions: TestCaseParser.CompilerSettings): CompileFilesResult; };
+
     export function compileFiles(
         inputFiles: TestFile[],
         otherFiles: TestFile[],
@@ -379,7 +382,8 @@ export namespace Compiler {
         // Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file
         currentDirectory: string | undefined,
         symlinks?: vfs.FileSet,
-    ): compiler.CompilationResult {
+    ): CompileFilesResult {
+        const originalCurrentDirectory = currentDirectory;
         const options: ts.CompilerOptions & HarnessOptions = compilerOptions ? ts.cloneCompilerOptions(compilerOptions) : { noResolve: false };
         options.newLine = options.newLine || ts.NewLineKind.CarriageReturnLineFeed;
         options.noErrorTruncation = true;
@@ -428,7 +432,8 @@ export namespace Compiler {
         const host = new fakes.CompilerHost(fs, options);
         const result = compiler.compileFiles(host, programFileNames, options, typeScriptVersion);
         result.symlinks = symlinks;
-        return result;
+        (result as CompileFilesResult).repeat = newOptions => compileFiles(inputFiles, otherFiles, { ...harnessSettings, ...newOptions }, compilerOptions, originalCurrentDirectory, symlinks);
+        return result as CompileFilesResult;
     }
 
     export interface DeclarationCompilationContext {
@@ -944,7 +949,7 @@ export namespace Compiler {
         return "\n//// https://sokra.github.io/source-map-visualization" + hash + "\n";
     }
 
-    export function doJsEmitBaseline(baselinePath: string, header: string, options: ts.CompilerOptions, result: compiler.CompilationResult, tsConfigFiles: readonly TestFile[], toBeCompiled: readonly TestFile[], otherFiles: readonly TestFile[], harnessSettings: TestCaseParser.CompilerSettings) {
+    export function doJsEmitBaseline(baselinePath: string, header: string, options: ts.CompilerOptions, result: CompileFilesResult, tsConfigFiles: readonly TestFile[], toBeCompiled: readonly TestFile[], otherFiles: readonly TestFile[], harnessSettings: TestCaseParser.CompilerSettings) {
         if (!options.noEmit && !options.emitDeclarationOnly && result.js.size === 0 && result.diagnostics.length === 0) {
             throw new Error("Expected at least one js file to be emitted or at least one error to be created.");
         }
@@ -996,9 +1001,33 @@ export namespace Compiler {
             jsCode += "\r\n\r\n";
             jsCode += getErrorBaseline(tsConfigFiles.concat(declFileCompilationResult.declInputFiles, declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.diagnostics);
         }
+        else if (!options.noCheck && !options.noEmit && (options.composite || options.declaration || options.emitDeclarationOnly)) {
+            const withoutChecking = result.repeat({ noCheck: "true", emitDeclarationOnly: "true" });
+            compareResultFileSets(withoutChecking.dts, result.dts);
+        }
 
         // eslint-disable-next-line no-restricted-syntax
         Baseline.runBaseline(baselinePath.replace(/\.tsx?/, ts.Extension.Js), jsCode.length > 0 ? tsCode + "\r\n\r\n" + jsCode : null);
+
+        function compareResultFileSets(a: ReadonlyMap<string, documents.TextDocument>, b: ReadonlyMap<string, documents.TextDocument>) {
+            a.forEach((doc, key) => {
+                const original = b.get(key);
+                if (!original) {
+                    jsCode += `\r\n\r\n!!!! File ${Utils.removeTestPathPrefixes(doc.file)} missing from original emit, but present in noCheck emit\r\n`;
+                    jsCode += fileOutput(doc, harnessSettings);
+                }
+                else if (original.text !== doc.text) {
+                    jsCode += `\r\n\r\n!!!! File ${Utils.removeTestPathPrefixes(doc.file)} differs from original emit in noCheck emit\r\n`;
+                    const Diff = require("diff");
+                    const expected = original.text;
+                    const actual = doc.text;
+                    const patch = Diff.createTwoFilesPatch("Expected", "Actual", expected, actual, "The full check baseline", "with noCheck set");
+                    const fileName = harnessSettings.fullEmitPaths ? Utils.removeTestPathPrefixes(doc.file) : ts.getBaseFileName(doc.file);
+                    jsCode += "//// [" + fileName + "]\r\n";
+                    jsCode += patch;
+                }
+            });
+        }
     }
 
     function fileOutput(file: documents.TextDocument, harnessSettings: TestCaseParser.CompilerSettings): string {

src/services/transpile.ts

@@ -75,6 +75,7 @@ export function transpileModule(input: string, transpileOptions: TranspileOption
  * - noResolve = true
  * - declaration = true
  * - emitDeclarationOnly = true
+ * - noCheck = true
  * Note that this declaration file may differ from one produced by a full program typecheck,
  * in that only types in the single input file are available to be used in the generated declarations.
  */
@@ -141,6 +142,7 @@ function transpileWorker(input: string, transpileOptions: TranspileOptions, decl
         options.declaration = true;
         options.emitDeclarationOnly = true;
         options.isolatedDeclarations = true;
+        options.noCheck = true;
     }
     else {
         options.declaration = false;

src/testRunner/compilerRunner.ts

@@ -1,4 +1,3 @@
-import * as compiler from "./_namespaces/compiler";
 import {
     Baseline,
     Compiler,
@@ -171,7 +170,7 @@ class CompilerTest {
     private configuredName: string;
     private harnessSettings: TestCaseParser.CompilerSettings;
     private hasNonDtsFiles: boolean;
-    private result: compiler.CompilationResult;
+    private result: Compiler.CompileFilesResult;
     private options: ts.CompilerOptions;
     private tsConfigFiles: Compiler.TestFile[];
     // equivalent to the files that will be passed on the command line

src/testRunner/tests.ts

@@ -86,6 +86,7 @@ import "./unittests/tsbuild/lateBoundSymbol";
 import "./unittests/tsbuild/libraryResolution";
 import "./unittests/tsbuild/moduleResolution";
 import "./unittests/tsbuild/moduleSpecifiers";
+import "./unittests/tsbuild/noCheck";
 import "./unittests/tsbuild/noEmit";
 import "./unittests/tsbuild/noEmitOnError";
 import "./unittests/tsbuild/outFile";

src/testRunner/unittests/tsbuild/noCheck.ts

@@ -0,0 +1,86 @@
+import {
+    CommandLineOption,
+    optionDeclarations,
+} from "../../_namespaces/ts";
+import { jsonToReadableText } from "../helpers";
+import {
+    noChangeRun,
+    verifyTsc,
+} from "../helpers/tsc";
+import { loadProjectFromFiles } from "../helpers/vfs";
+
+function verifyNoCheckFlag(variant: string) {
+    function verifyNoCheckWorker(subScenario: string, declAText: string, commandLineArgs: readonly string[]) {
+        verifyTsc({
+            scenario: variant,
+            subScenario,
+            fs: () =>
+                loadProjectFromFiles({
+                    "/src/a.ts": getATsContent(declAText),
+                    "/src/tsconfig.json": jsonToReadableText({
+                        compilerOptions: { noCheck: true, emitDeclarationOnly: true, declaration: true },
+                    }),
+                }),
+            commandLineArgs,
+            edits: [
+                noChangeRun,
+                {
+                    caption: "Fix `a` error",
+                    edit: fs => fs.writeFileSync("/src/a.ts", getATsContent(`const a = "hello"`)),
+                },
+                noChangeRun,
+                {
+                    caption: "Disable noCheck",
+                    edit: fs =>
+                        fs.writeFileSync(
+                            "/src/tsconfig.json",
+                            jsonToReadableText({
+                                compilerOptions: { emitDeclarationOnly: true, declaration: true },
+                            }),
+                        ),
+                },
+                noChangeRun,
+            ],
+            baselinePrograms: true,
+        });
+
+        function getATsContent(declAText: string) {
+            return `const err: number = "error";
+${declAText}`;
+        }
+    }
+
+    function verifyNoCheck(subScenario: string, aTsContent: string) {
+        verifyNoCheckWorker(subScenario, aTsContent, ["--b", "/src/tsconfig.json", "-v"]);
+        verifyNoCheckWorker(`${subScenario} with incremental`, aTsContent, ["--b", "/src/tsconfig.json", "-v", "--incremental"]);
+    }
+
+    verifyNoCheck("syntax errors", `const a = "hello`);
+    verifyNoCheck("semantic errors", `const a: number = "hello"`);
+}
+
+describe("unittests:: tsbuild:: noCheck", () => {
+    // Enable the `noCheck` option on the CLI for testing purposes, to ensure it works with incremental/build
+    let validate: CommandLineOption["extraValidation"];
+    before(() => {
+        for (const opt of optionDeclarations) {
+            if (opt.name === "noCheck") {
+                validate = opt.extraValidation;
+                opt.extraValidation = () => undefined;
+            }
+        }
+    });
+    after(() => {
+        for (const opt of optionDeclarations) {
+            if (opt.name === "noCheck") {
+                opt.extraValidation = validate;
+            }
+        }
+    });
+
+    verifyNoCheckFlag("noCheck");
+});
+
+describe("unittests:: tsbuild:: noCheck:: errors", () => {
+    verifyNoCheckFlag("noCheck-errors");
+});

tests/baselines/reference/config/showConfig/Shows tsconfig for single option/noCheck/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "compilerOptions": {}
+}

tests/baselines/reference/deferredLookupTypeResolution.js

@@ -62,3 +62,20 @@ declare function f3(x: 'a' | 'b'): {
     b: any;
     x: any;
 };
+
+
+!!!! File deferredLookupTypeResolution.d.ts differs from original emit in noCheck emit
+//// [deferredLookupTypeResolution.d.ts]
+===================================================================
+--- Expected	The full check baseline
++++ Actual	with noCheck set
+@@ -15,8 +15,8 @@
+     [P in A | B]: any;
+ };
+ declare function f2<A extends string>(a: A): { [P in A | "x"]: any; };
+ declare function f3(x: 'a' | 'b'): {
++    x: any;
+     a: any;
+     b: any;
+-    x: any;
+ };

tests/baselines/reference/indexSignatures1.js

@@ -680,3 +680,21 @@ type Rec1 = {
 type Rec2 = Record<Id, number>;
 type K1 = keyof Rec1;
 type K2 = keyof Rec2;
+
+
+!!!! File indexSignatures1.d.ts differs from original emit in noCheck emit
+//// [indexSignatures1.d.ts]
+===================================================================
+--- Expected	The full check baseline
++++ Actual	with noCheck set
+@@ -118,9 +118,9 @@
+     [x: symbol]: 4 | 5;
+     [sym]: 4;
+ };
+ declare const obj13: {
+-    [x: string]: 0 | 2 | 1 | 3;
++    [x: string]: 0 | 1 | 2 | 3;
+     [x: number]: 2 | 3;
+     [x: symbol]: 4 | 5;
+     x: 0;
+     1: 2;

tests/baselines/reference/jsDeclarationsCrossfileMerge.js

@@ -27,3 +27,9 @@ module.exports.memberName = "thing";
 declare const _exports: typeof m.default;
 export = _exports;
 import m = require("./exporter");
+
+
+!!!! File out/exporter.d.ts missing from original emit, but present in noCheck emit
+//// [exporter.d.ts]
+export default validate;
+declare function validate(): void;

tests/baselines/reference/noCheckDoesNotReportError.js

@@ -0,0 +1,10 @@
+//// [tests/cases/compiler/noCheckDoesNotReportError.ts] ////
+
+//// [noCheckDoesNotReportError.ts]
+export const a: number = "not ok";
+
+
+
+
+//// [noCheckDoesNotReportError.d.ts]
+export declare const a: number;

tests/baselines/reference/noCheckDoesNotReportError.symbols

@@ -0,0 +1,6 @@
+//// [tests/cases/compiler/noCheckDoesNotReportError.ts] ////
+
+=== noCheckDoesNotReportError.ts ===
+export const a: number = "not ok";
+>a : Symbol(a, Decl(noCheckDoesNotReportError.ts, 0, 12))
+

tests/baselines/reference/noCheckDoesNotReportError.types

@@ -0,0 +1,9 @@
+//// [tests/cases/compiler/noCheckDoesNotReportError.ts] ////
+
+=== noCheckDoesNotReportError.ts ===
+export const a: number = "not ok";
+>a : number
+>  : ^^^^^^
+>"not ok" : "not ok"
+>         : ^^^^^^^^
+

tests/baselines/reference/noCheckNoEmit.errors.txt

@@ -0,0 +1,9 @@
+error TS5053: Option 'emitDeclarationOnly' cannot be specified with option 'noEmit'.
+error TS5053: Option 'noCheck' cannot be specified with option 'noEmit'.
+
+
+!!! error TS5053: Option 'emitDeclarationOnly' cannot be specified with option 'noEmit'.
+!!! error TS5053: Option 'noCheck' cannot be specified with option 'noEmit'.
+==== noCheckNoEmit.ts (0 errors) ====
+    export const a: number = "not ok";
+

tests/baselines/reference/noCheckNoEmit.symbols

@@ -0,0 +1,6 @@
+//// [tests/cases/compiler/noCheckNoEmit.ts] ////
+
+=== noCheckNoEmit.ts ===
+export const a: number = "not ok";
+>a : Symbol(a, Decl(noCheckNoEmit.ts, 0, 12))
+