microsoft
diff --git a/‎src/compiler/builder.ts
Copy file name to clipboard
+5-2Lines changed: 5 additions & 2 deletions b/‎src/compiler/builder.ts
Copy file name to clipboard
+5-2Lines changed: 5 additions & 2 deletions
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+25-10Lines changed: 25 additions & 10 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+25-10Lines changed: 25 additions & 10 deletions
diff --git a/‎src/compiler/commandLineParser.ts
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion b/‎src/compiler/commandLineParser.ts
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎src/compiler/emitter.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/compiler/emitter.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎src/compiler/program.ts
Copy file name to clipboard
+17-9Lines changed: 17 additions & 9 deletions b/‎src/compiler/program.ts
Copy file name to clipboard
+17-9Lines changed: 17 additions & 9 deletions
diff --git a/‎src/compiler/types.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎src/compiler/types.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎src/testRunner/unittests/tsbuild/helpers.ts
Copy file name to clipboard
+16-12Lines changed: 16 additions & 12 deletions b/‎src/testRunner/unittests/tsbuild/helpers.ts
Copy file name to clipboard
+16-12Lines changed: 16 additions & 12 deletions
@@ -5,6 +5,7 @@ namespace ts {
         reportsUnnecessary?: {};
         source?: string;
         relatedInformation?: ReusableDiagnosticRelatedInformation[];
+        skippedOn?: keyof CompilerOptions;
     }
 
     export interface ReusableDiagnosticRelatedInformation {
@@ -268,6 +269,7 @@ namespace ts {
             const result: Diagnostic = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath);
             result.reportsUnnecessary = diagnostic.reportsUnnecessary;
             result.source = diagnostic.source;
+            result.skippedOn = diagnostic.skippedOn;
             const { relatedInformation } = diagnostic;
             result.relatedInformation = relatedInformation ?
                 relatedInformation.length ?
@@ -676,7 +678,7 @@ namespace ts {
             const cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path);
             // Report the bind and check diagnostics from the cache if we already have those diagnostics present
             if (cachedDiagnostics) {
-                return cachedDiagnostics;
+                return filterSemanticDiagnotics(cachedDiagnostics, state.compilerOptions);
             }
         }
 
@@ -685,7 +687,7 @@ namespace ts {
         if (state.semanticDiagnosticsPerFile) {
             state.semanticDiagnosticsPerFile.set(path, diagnostics);
         }
-        return diagnostics;
+        return filterSemanticDiagnotics(diagnostics, state.compilerOptions);
     }
 
     export type ProgramBuildInfoDiagnostic = string | [string, readonly ReusableDiagnostic[]];
@@ -816,6 +818,7 @@ namespace ts {
             const result: ReusableDiagnostic = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
             result.reportsUnnecessary = diagnostic.reportsUnnecessary;
             result.source = diagnostic.source;
+            result.skippedOn = diagnostic.skippedOn;
             const { relatedInformation } = diagnostic;
             result.relatedInformation = relatedInformation ?
                 relatedInformation.length ?
 
@@ -1029,6 +1029,12 @@ namespace ts {
             }
         }
 
+        function errorSkippedOn(key: keyof CompilerOptions, location: Node | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
+            const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+            diagnostic.skippedOn = key;
+            return diagnostic;
+        }
+
         function error(location: Node | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
             const diagnostic = location
                 ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3)
@@ -32057,13 +32063,13 @@ namespace ts {
 
         function checkCollisionWithArgumentsInGeneratedCode(node: SignatureDeclaration) {
             // no rest parameters \ declaration context \ overload - no codegen impact
-            if (languageVersion >= ScriptTarget.ES2015 || compilerOptions.noEmit || !hasRestParameter(node) || node.flags & NodeFlags.Ambient || nodeIsMissing((<FunctionLikeDeclaration>node).body)) {
+            if (languageVersion >= ScriptTarget.ES2015 || !hasRestParameter(node) || node.flags & NodeFlags.Ambient || nodeIsMissing((<FunctionLikeDeclaration>node).body)) {
                 return;
             }
 
             forEach(node.parameters, p => {
                 if (p.name && !isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {
-                    error(p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
+                    errorSkippedOn("noEmit", p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
                 }
             });
         }
@@ -32133,13 +32139,13 @@ namespace ts {
         function checkWeakMapCollision(node: Node) {
             const enclosingBlockScope = getEnclosingBlockScopeContainer(node);
             if (getNodeCheckFlags(enclosingBlockScope) & NodeCheckFlags.ContainsClassWithPrivateIdentifiers) {
-                error(node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap");
+                errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap");
             }
         }
 
         function checkCollisionWithRequireExportsInGeneratedCode(node: Node, name: Identifier) {
             // No need to check for require or exports for ES6 modules and later
-            if (moduleKind >= ModuleKind.ES2015 || compilerOptions.noEmit) {
+            if (moduleKind >= ModuleKind.ES2015) {
                 return;
             }
 
@@ -32156,13 +32162,13 @@ namespace ts {
             const parent = getDeclarationContainer(node);
             if (parent.kind === SyntaxKind.SourceFile && isExternalOrCommonJsModule(<SourceFile>parent)) {
                 // If the declaration happens to be in external module, report error that require and exports are reserved keywords
-                error(name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,
+                errorSkippedOn("noEmit", name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,
                     declarationNameToString(name), declarationNameToString(name));
             }
         }
 
         function checkCollisionWithGlobalPromiseInGeneratedCode(node: Node, name: Identifier): void {
-            if (languageVersion >= ScriptTarget.ES2017 || compilerOptions.noEmit || !needCollisionCheckForIdentifier(node, name, "Promise")) {
+            if (languageVersion >= ScriptTarget.ES2017 || !needCollisionCheckForIdentifier(node, name, "Promise")) {
                 return;
             }
 
@@ -32175,7 +32181,7 @@ namespace ts {
             const parent = getDeclarationContainer(node);
             if (parent.kind === SyntaxKind.SourceFile && isExternalOrCommonJsModule(<SourceFile>parent) && parent.flags & NodeFlags.HasAsyncFunctions) {
                 // If the declaration happens to be in external module, report error that Promise is a reserved identifier.
-                error(name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,
+                errorSkippedOn("noEmit", name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,
                     declarationNameToString(name), declarationNameToString(name));
             }
         }
@@ -32393,7 +32399,7 @@ namespace ts {
                 }
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
                 checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
-                if (!compilerOptions.noEmit && languageVersion < ScriptTarget.ESNext && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) {
+                if (languageVersion < ScriptTarget.ESNext && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) {
                     potentialWeakMapCollisions.push(node);
                 }
             }
@@ -38316,7 +38322,7 @@ namespace ts {
 
             const moduleKind = getEmitModuleKind(compilerOptions);
 
-            if (moduleKind < ModuleKind.ES2015 && moduleKind !== ModuleKind.System && !compilerOptions.noEmit &&
+            if (moduleKind < ModuleKind.ES2015 && moduleKind !== ModuleKind.System &&
                 !(node.parent.parent.flags & NodeFlags.Ambient) && hasSyntacticModifier(node.parent.parent, ModifierFlags.Export)) {
                 checkESModuleMarker(node.name);
             }
@@ -38336,7 +38342,7 @@ namespace ts {
         function checkESModuleMarker(name: Identifier | BindingPattern): boolean {
             if (name.kind === SyntaxKind.Identifier) {
                 if (idText(name) === "__esModule") {
-                    return grammarErrorOnNode(name, Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);
+                    return grammarErrorOnNodeSkippedOn("noEmit", name, Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);
                 }
             }
             else {
@@ -38446,6 +38452,15 @@ namespace ts {
             return false;
         }
 
+        function grammarErrorOnNodeSkippedOn(key: keyof CompilerOptions, node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
+            const sourceFile = getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                errorSkippedOn(key, node, message, arg0, arg1, arg2);
+                return true;
+            }
+            return false;
+        }
+
         function grammarErrorOnNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
             const sourceFile = getSourceFileOfNode(node);
             if (!hasParseDiagnostics(sourceFile)) {
 
@@ -462,7 +462,6 @@ namespace ts {
         {
             name: "noEmit",
             type: "boolean",
-            affectsEmit: true,
             showInSimplifiedHelpView: true,
             category: Diagnostics.Basic_Options,
             description: Diagnostics.Do_not_emit_outputs,
 
@@ -4458,6 +4458,10 @@
         "category": "Error",
         "code": 6309
     },
+    "Referenced project '{0}' may not disable emit.": {
+        "category": "Error",
+        "code": 6310
+    },
     "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'": {
         "category": "Message",
         "code": 6350
 
@@ -333,7 +333,7 @@ namespace ts {
             // Write build information if applicable
             if (!buildInfoPath || targetSourceFile || emitSkipped) return;
             const program = host.getProgramBuildInfo();
-            if (host.isEmitBlocked(buildInfoPath) || compilerOptions.noEmit) {
+            if (host.isEmitBlocked(buildInfoPath)) {
                 emitSkipped = true;
                 return;
             }
 
@@ -1719,7 +1719,7 @@ namespace ts {
 
         function getSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): readonly Diagnostic[] {
             return concatenate(
-                getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken),
+                filterSemanticDiagnotics(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), options),
                 getProgramDiagnostics(sourceFile)
             );
         }
@@ -3011,10 +3011,6 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
             }
 
-            if (!options.listFilesOnly && options.noEmit && isIncrementalCompilation(options)) {
-                createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noEmit", options.incremental ? "incremental" : "composite");
-            }
-
             verifyProjectReferences();
 
             // List of collected files is complete; validate exhautiveness if this is a project with a file list
@@ -3278,7 +3274,7 @@ namespace ts {
         }
 
         function verifyProjectReferences() {
-            const buildInfoPath = !options.noEmit && !options.suppressOutputPathCheck ? getTsBuildInfoEmitOutputFilePath(options) : undefined;
+            const buildInfoPath = !options.suppressOutputPathCheck ? getTsBuildInfoEmitOutputFilePath(options) : undefined;
             forEachProjectReference(projectReferences, resolvedProjectReferences, (resolvedRef, index, parent) => {
                 const ref = (parent ? parent.commandLine.projectReferences : projectReferences)![index];
                 const parentFile = parent && parent.sourceFile as JsonSourceFile;
@@ -3287,11 +3283,12 @@ namespace ts {
                     return;
                 }
                 const options = resolvedRef.commandLine.options;
-                if (!options.composite) {
+                if (!options.composite || options.noEmit) {
                     // ok to not have composite if the current program is container only
                     const inputs = parent ? parent.commandLine.fileNames : rootNames;
                     if (inputs.length) {
-                        createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
+                        if (!options.composite) createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
+                        if (options.noEmit) createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path);
                     }
                 }
                 if (ref.prepend) {
@@ -3657,7 +3654,13 @@ namespace ts {
         cancellationToken: CancellationToken | undefined
     ): EmitResult | undefined {
         const options = program.getCompilerOptions();
-        if (options.noEmit) return emitSkippedWithNoDiagnostics;
+        if (options.noEmit) {
+            // Cache the semantic diagnostics
+            program.getSemanticDiagnostics(sourceFile, cancellationToken);
+            return sourceFile || outFile(options) ?
+                emitSkippedWithNoDiagnostics :
+                program.emitBuildInfo(writeFile, cancellationToken);
+        }
 
         // If the noEmitOnError flag is set, then check if we have any errors so far.  If so,
         // immediately bail out.  Note that we pass 'undefined' for 'sourceFile' so that we
@@ -3684,6 +3687,11 @@ namespace ts {
         return { diagnostics, sourceMaps: undefined, emittedFiles, emitSkipped: true };
     }
 
+    /*@internal*/
+    export function filterSemanticDiagnotics(diagnostic: readonly Diagnostic[], option: CompilerOptions): readonly Diagnostic[] {
+        return filter(diagnostic, d => !d.skippedOn || !option[d.skippedOn]);
+    }
+
     /*@internal*/
     interface CompilerHostLike {
         useCaseSensitiveFileNames(): boolean;
 
@@ -5525,6 +5525,7 @@ namespace ts {
         reportsUnnecessary?: {};
         source?: string;
         relatedInformation?: DiagnosticRelatedInformation[];
+        /* @internal */ skippedOn?: keyof CompilerOptions;
     }
 
     export interface DiagnosticRelatedInformation {
 
@@ -296,9 +296,9 @@ interface Symbol {
                 }
                 else if (actualText !== expectedText) {
                     // Verify build info without affectedFilesPendingEmit
-                    const { text: actualBuildInfoText, affectedFilesPendingEmit: actualAffectedFilesPendingEmit } = getBuildInfoWithoutAffectedFilesPendingEmit(actualText);
-                    const { text: expectedBuildInfoText, affectedFilesPendingEmit: expectedAffectedFilesPendingEmit } = getBuildInfoWithoutAffectedFilesPendingEmit(expectedText);
-                    assert.equal(actualBuildInfoText, expectedBuildInfoText, `TsBuild info text without affectedFilesPendingEmit: ${outputFile}::\nIncremental buildInfoText:: ${actualText}\nClean buildInfoText:: ${expectedText}`);
+                    const { buildInfo: actualBuildInfo, affectedFilesPendingEmit: actualAffectedFilesPendingEmit } = getBuildInfoForIncrementalCorrectnessCheck(actualText);
+                    const { buildInfo: expectedBuildInfo, affectedFilesPendingEmit: expectedAffectedFilesPendingEmit } = getBuildInfoForIncrementalCorrectnessCheck(expectedText);
+                    assert.deepEqual(actualBuildInfo, expectedBuildInfo, `TsBuild info text without affectedFilesPendingEmit: ${outputFile}::\nIncremental buildInfoText:: ${actualText}\nClean buildInfoText:: ${expectedText}`);
                     // Verify that incrementally pending affected file emit are in clean build since clean build can contain more files compared to incremental depending of noEmitOnError option
                     if (actualAffectedFilesPendingEmit) {
                         assert.isDefined(expectedAffectedFilesPendingEmit, `Incremental build contains affectedFilesPendingEmit, clean build should also have it: ${outputFile}::\nIncremental buildInfoText:: ${actualText}\nClean buildInfoText:: ${expectedText}`);
@@ -314,15 +314,19 @@ interface Symbol {
         });
     }
 
-    function getBuildInfoWithoutAffectedFilesPendingEmit(text: string | undefined): { text: string | undefined; affectedFilesPendingEmit?: ProgramBuildInfo["affectedFilesPendingEmit"]; } {
+    function getBuildInfoForIncrementalCorrectnessCheck(text: string | undefined): { buildInfo: BuildInfo | undefined; affectedFilesPendingEmit?: ProgramBuildInfo["affectedFilesPendingEmit"]; } {
         const buildInfo = text ? getBuildInfo(text) : undefined;
-        if (!buildInfo?.program?.affectedFilesPendingEmit) return { text };
-        const { program: { affectedFilesPendingEmit, ...programRest }, ...rest } = buildInfo;
+        if (!buildInfo?.program) return { buildInfo };
+        // Ignore noEmit since that shouldnt be reason to emit the tsbuild info and presence of it in the buildinfo file does not matter
+        const { program: { affectedFilesPendingEmit, options: { noEmit, ...optionsRest}, ...programRest }, ...rest } = buildInfo;
         return {
-            text: getBuildInfoText({
+            buildInfo: {
                 ...rest,
-                program: programRest
-            }),
+                program: {
+                    options: optionsRest,
+                    ...programRest
+                }
+            },
             affectedFilesPendingEmit
         };
     }
@@ -423,7 +427,7 @@ interface Symbol {
                         subScenario,
                         baseFs,
                         newSys,
-                        commandLineArgs,
+                        commandLineArgs: incrementalCommandLineArgs || commandLineArgs,
                         incrementalModifyFs,
                         modifyFs,
                         tick
@@ -515,12 +519,12 @@ interface Symbol {
                 }));
             });
             describe("incremental correctness", () => {
-                incrementalScenarios.forEach((_, index) => verifyIncrementalCorrectness(() => ({
+                incrementalScenarios.forEach(({ commandLineArgs: incrementalCommandLineArgs }, index) => verifyIncrementalCorrectness(() => ({
                     scenario,
                     subScenario,
                     baseFs,
                     newSys: incrementalSys[index],
-                    commandLineArgs,
+                    commandLineArgs: incrementalCommandLineArgs || commandLineArgs,
                     incrementalModifyFs: fs => {
                         for (let i = 0; i <= index; i++) {
                             incrementalScenarios[i].modifyFs(fs);
Original file line number	Diff line number	Diff line change
`@@ -1029,6 +1029,12 @@ namespace ts {`
`1029`	`1029`	`}`
`1030`	`1030`	`}`
`1031`	`1031`
	`1032`	`+ function errorSkippedOn(key: keyof CompilerOptions, location: Node \| undefined, message: DiagnosticMessage, arg0?: string \| number, arg1?: string \| number, arg2?: string \| number, arg3?: string \| number): Diagnostic {`
	`1033`	`+ const diagnostic = error(location, message, arg0, arg1, arg2, arg3);`
	`1034`	`+ diagnostic.skippedOn = key;`
	`1035`	`+ return diagnostic;`
	`1036`	`+ }`
	`1037`	`+`
`1032`	`1038`	`function error(location: Node \| undefined, message: DiagnosticMessage, arg0?: string \| number, arg1?: string \| number, arg2?: string \| number, arg3?: string \| number): Diagnostic {`
`1033`	`1039`	`const diagnostic = location`
`1034`	`1040`	`? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3)`
`@@ -32057,13 +32063,13 @@ namespace ts {`
`32057`	`32063`
`32058`	`32064`	`function checkCollisionWithArgumentsInGeneratedCode(node: SignatureDeclaration) {`
`32059`	`32065`	`// no rest parameters \ declaration context \ overload - no codegen impact`
`32060`		`- if (languageVersion >= ScriptTarget.ES2015 \|\| compilerOptions.noEmit \|\| !hasRestParameter(node) \|\| node.flags & NodeFlags.Ambient \|\| nodeIsMissing((<FunctionLikeDeclaration>node).body)) {`
	`32066`	`+ if (languageVersion >= ScriptTarget.ES2015 \|\| !hasRestParameter(node) \|\| node.flags & NodeFlags.Ambient \|\| nodeIsMissing((<FunctionLikeDeclaration>node).body)) {`
`32061`	`32067`	`return;`
`32062`	`32068`	`}`
`32063`	`32069`
`32064`	`32070`	`forEach(node.parameters, p => {`
`32065`	`32071`	`if (p.name && !isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {`
`32066`		`- error(p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);`
	`32072`	`+ errorSkippedOn("noEmit", p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);`
`32067`	`32073`	`}`
`32068`	`32074`	`});`
`32069`	`32075`	`}`
`@@ -32133,13 +32139,13 @@ namespace ts {`
`32133`	`32139`	`function checkWeakMapCollision(node: Node) {`
`32134`	`32140`	`const enclosingBlockScope = getEnclosingBlockScopeContainer(node);`
`32135`	`32141`	`if (getNodeCheckFlags(enclosingBlockScope) & NodeCheckFlags.ContainsClassWithPrivateIdentifiers) {`
`32136`		`- error(node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap");`
	`32142`	`+ errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, "WeakMap");`
`32137`	`32143`	`}`
`32138`	`32144`	`}`
`32139`	`32145`
`32140`	`32146`	`function checkCollisionWithRequireExportsInGeneratedCode(node: Node, name: Identifier) {`
`32141`	`32147`	`// No need to check for require or exports for ES6 modules and later`
`32142`		`- if (moduleKind >= ModuleKind.ES2015 \|\| compilerOptions.noEmit) {`
	`32148`	`+ if (moduleKind >= ModuleKind.ES2015) {`
`32143`	`32149`	`return;`
`32144`	`32150`	`}`
`32145`	`32151`
`@@ -32156,13 +32162,13 @@ namespace ts {`
`32156`	`32162`	`const parent = getDeclarationContainer(node);`
`32157`	`32163`	`if (parent.kind === SyntaxKind.SourceFile && isExternalOrCommonJsModule(<SourceFile>parent)) {`
`32158`	`32164`	`// If the declaration happens to be in external module, report error that require and exports are reserved keywords`
`32159`		`- error(name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,`
	`32165`	`+ errorSkippedOn("noEmit", name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,`
`32160`	`32166`	`declarationNameToString(name), declarationNameToString(name));`
`32161`	`32167`	`}`
`32162`	`32168`	`}`
`32163`	`32169`
`32164`	`32170`	`function checkCollisionWithGlobalPromiseInGeneratedCode(node: Node, name: Identifier): void {`
`32165`		`- if (languageVersion >= ScriptTarget.ES2017 \|\| compilerOptions.noEmit \|\| !needCollisionCheckForIdentifier(node, name, "Promise")) {`
	`32171`	`+ if (languageVersion >= ScriptTarget.ES2017 \|\| !needCollisionCheckForIdentifier(node, name, "Promise")) {`
`32166`	`32172`	`return;`
`32167`	`32173`	`}`
`32168`	`32174`
`@@ -32175,7 +32181,7 @@ namespace ts {`
`32175`	`32181`	`const parent = getDeclarationContainer(node);`
`32176`	`32182`	`if (parent.kind === SyntaxKind.SourceFile && isExternalOrCommonJsModule(<SourceFile>parent) && parent.flags & NodeFlags.HasAsyncFunctions) {`
`32177`	`32183`	`// If the declaration happens to be in external module, report error that Promise is a reserved identifier.`
`32178`		`- error(name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,`
	`32184`	`+ errorSkippedOn("noEmit", name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,`
`32179`	`32185`	`declarationNameToString(name), declarationNameToString(name));`
`32180`	`32186`	`}`
`32181`	`32187`	`}`
`@@ -32393,7 +32399,7 @@ namespace ts {`
`32393`	`32399`	`}`
`32394`	`32400`	`checkCollisionWithRequireExportsInGeneratedCode(node, node.name);`
`32395`	`32401`	`checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);`
`32396`		`- if (!compilerOptions.noEmit && languageVersion < ScriptTarget.ESNext && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) {`
	`32402`	`+ if (languageVersion < ScriptTarget.ESNext && needCollisionCheckForIdentifier(node, node.name, "WeakMap")) {`
`32397`	`32403`	`potentialWeakMapCollisions.push(node);`
`32398`	`32404`	`}`
`32399`	`32405`	`}`
`@@ -38316,7 +38322,7 @@ namespace ts {`
`38316`	`38322`
`38317`	`38323`	`const moduleKind = getEmitModuleKind(compilerOptions);`
`38318`	`38324`
`38319`		`- if (moduleKind < ModuleKind.ES2015 && moduleKind !== ModuleKind.System && !compilerOptions.noEmit &&`
	`38325`	`+ if (moduleKind < ModuleKind.ES2015 && moduleKind !== ModuleKind.System &&`
`38320`	`38326`	`!(node.parent.parent.flags & NodeFlags.Ambient) && hasSyntacticModifier(node.parent.parent, ModifierFlags.Export)) {`
`38321`	`38327`	`checkESModuleMarker(node.name);`
`38322`	`38328`	`}`
`@@ -38336,7 +38342,7 @@ namespace ts {`
`38336`	`38342`	`function checkESModuleMarker(name: Identifier \| BindingPattern): boolean {`
`38337`	`38343`	`if (name.kind === SyntaxKind.Identifier) {`
`38338`	`38344`	`if (idText(name) === "__esModule") {`
`38339`		`- return grammarErrorOnNode(name, Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);`
	`38345`	`+ return grammarErrorOnNodeSkippedOn("noEmit", name, Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);`
`38340`	`38346`	`}`
`38341`	`38347`	`}`
`38342`	`38348`	`else {`
`@@ -38446,6 +38452,15 @@ namespace ts {`
`38446`	`38452`	`return false;`
`38447`	`38453`	`}`
`38448`	`38454`
	`38455`	`+ function grammarErrorOnNodeSkippedOn(key: keyof CompilerOptions, node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {`
	`38456`	`+ const sourceFile = getSourceFileOfNode(node);`
	`38457`	`+ if (!hasParseDiagnostics(sourceFile)) {`
	`38458`	`+ errorSkippedOn(key, node, message, arg0, arg1, arg2);`
	`38459`	`+ return true;`
	`38460`	`+ }`
	`38461`	`+ return false;`
	`38462`	`+ }`
	`38463`	`+`
`38449`	`38464`	`function grammarErrorOnNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {`
`38450`	`38465`	`const sourceFile = getSourceFileOfNode(node);`
`38451`	`38466`	`if (!hasParseDiagnostics(sourceFile)) {`
Original file line number	Diff line number	Diff line change
`@@ -462,7 +462,6 @@ namespace ts {`
`462`	`462`	`{`
`463`	`463`	`name: "noEmit",`
`464`	`464`	`type: "boolean",`
`465`		`- affectsEmit: true,`
`466`	`465`	`showInSimplifiedHelpView: true,`
`467`	`466`	`category: Diagnostics.Basic_Options,`
`468`	`467`	`description: Diagnostics.Do_not_emit_outputs,`
Original file line number	Diff line number	Diff line change
`@@ -333,7 +333,7 @@ namespace ts {`
`333`	`333`	`// Write build information if applicable`
`334`	`334`	`if (!buildInfoPath \|\| targetSourceFile \|\| emitSkipped) return;`
`335`	`335`	`const program = host.getProgramBuildInfo();`
`336`		`- if (host.isEmitBlocked(buildInfoPath) \|\| compilerOptions.noEmit) {`
	`336`	`+ if (host.isEmitBlocked(buildInfoPath)) {`
`337`	`337`	`emitSkipped = true;`
`338`	`338`	`return;`
`339`	`339`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5525,6 +5525,7 @@ namespace ts {`
`5525`	`5525`	`reportsUnnecessary?: {};`
`5526`	`5526`	`source?: string;`
`5527`	`5527`	`relatedInformation?: DiagnosticRelatedInformation[];`
	`5528`	`+ /* @internal */ skippedOn?: keyof CompilerOptions;`
`5528`	`5529`	`}`
`5529`	`5530`
`5530`	`5531`	`export interface DiagnosticRelatedInformation {`