Do not include global errors in semantic errors from the file (microsoft#37545)

Fixes microsoft#37084

Author: sheetalkamat

src/server/session.ts

@@ -856,7 +856,7 @@ namespace ts.server {
         private semanticCheck(file: NormalizedPath, project: Project) {
             const diags = isDeclarationFileInJSOnlyNonConfiguredProject(project, file)
                 ? emptyArray
-                : project.getLanguageService().getSemanticDiagnostics(file);
+                : project.getLanguageService().getSemanticDiagnostics(file).filter(d => !!d.file);
             this.sendDiagnosticsEvent(file, project, diags, "semanticDiag");
         }
 
@@ -1234,7 +1234,7 @@ namespace ts.server {
             if (configFile) {
                 return this.getConfigFileDiagnostics(configFile, project!, !!args.includeLinePosition); // TODO: GH#18217
             }
-            return this.getDiagnosticsWorker(args, /*isSemantic*/ true, (project, file) => project.getLanguageService().getSemanticDiagnostics(file), !!args.includeLinePosition);
+            return this.getDiagnosticsWorker(args, /*isSemantic*/ true, (project, file) => project.getLanguageService().getSemanticDiagnostics(file).filter(d => !!d.file), !!args.includeLinePosition);
         }
 
         private getSuggestionDiagnosticsSync(args: protocol.SuggestionDiagnosticsSyncRequestArgs): readonly protocol.Diagnostic[] | readonly protocol.DiagnosticWithLinePosition[] {

src/testRunner/unittests/tsserver/helpers.ts

@@ -807,4 +807,209 @@ namespace ts.projectSystem {
             lineText,
         };
     }
+
+    export interface GetErrDiagnostics {
+        file: string | File;
+        syntax?: protocol.Diagnostic[];
+        semantic?: protocol.Diagnostic[];
+        suggestion?: protocol.Diagnostic[];
+    }
+    export interface VerifyGetErrRequestBase {
+        session: TestSession;
+        host: TestServerHost;
+        onErrEvent?: () => void;
+        existingTimeouts?: number;
+    }
+    export interface VerifyGetErrRequest extends VerifyGetErrRequestBase {
+        expected: readonly GetErrDiagnostics[];
+    }
+    export function verifyGetErrRequest(request: VerifyGetErrRequest) {
+        const { session, expected } = request;
+        session.clearMessages();
+        const expectedSequenceId = session.getNextSeq();
+        session.executeCommandSeq<protocol.GeterrRequest>({
+            command: protocol.CommandTypes.Geterr,
+            arguments: {
+                delay: 0,
+                files: expected.map(f => filePath(f.file))
+            }
+        });
+        checkAllErrors({ ...request, expectedSequenceId });
+    }
+
+    export interface CheckAllErrors extends VerifyGetErrRequest {
+        expectedSequenceId: number;
+    }
+    function checkAllErrors({ expected, expectedSequenceId, ...rest }: CheckAllErrors) {
+        for (let i = 0; i < expected.length; i++) {
+            checkErrorsInFile({
+                ...rest,
+                expected: expected[i],
+                expectedSequenceId: i === expected.length - 1 ? expectedSequenceId : undefined,
+            });
+        }
+    }
+
+    function filePath(file: string | File) {
+        return isString(file) ? file : file.path;
+    }
+    interface CheckErrorsInFile extends VerifyGetErrRequestBase {
+        expected: GetErrDiagnostics;
+        expectedSequenceId?: number;
+    }
+    function checkErrorsInFile({
+        session, host, onErrEvent, existingTimeouts, expectedSequenceId,
+        expected: { file, syntax, semantic, suggestion },
+    }: CheckErrorsInFile) {
+        onErrEvent = onErrEvent || noop;
+        if (existingTimeouts !== undefined) {
+            host.checkTimeoutQueueLength(existingTimeouts + 1);
+            host.runQueuedTimeoutCallbacks(host.getNextTimeoutId() - 1);
+        }
+        else {
+            host.checkTimeoutQueueLengthAndRun(1);
+        }
+        if (syntax) {
+            onErrEvent();
+            checkErrorMessage(session, "syntaxDiag", { file: filePath(file), diagnostics: syntax });
+        }
+        if (semantic) {
+            session.clearMessages();
+
+            host.runQueuedImmediateCallbacks(1);
+            onErrEvent();
+            checkErrorMessage(session, "semanticDiag", { file: filePath(file), diagnostics: semantic });
+        }
+        if (suggestion) {
+            session.clearMessages();
+
+            host.runQueuedImmediateCallbacks(1);
+            onErrEvent();
+            checkErrorMessage(session, "suggestionDiag", { file: filePath(file), diagnostics: suggestion });
+        }
+        if (expectedSequenceId !== undefined) {
+            checkCompleteEvent(session, syntax || semantic || suggestion ? 2 : 1, expectedSequenceId);
+        }
+        session.clearMessages();
+    }
+
+    function verifyErrorsUsingGeterr({ allFiles, openFiles, expectedGetErr }: VerifyGetErrScenario) {
+        it("verifies the errors in open file", () => {
+            const host = createServerHost([...allFiles(), libFile]);
+            const session = createSession(host, { canUseEvents: true, });
+            openFilesForSession(openFiles(), session);
+
+            verifyGetErrRequest({ session, host, expected: expectedGetErr() });
+        });
+    }
+
+    function verifyErrorsUsingGeterrForProject({ allFiles, openFiles, expectedGetErrForProject }: VerifyGetErrScenario) {
+        it("verifies the errors in projects", () => {
+            const host = createServerHost([...allFiles(), libFile]);
+            const session = createSession(host, { canUseEvents: true, });
+            openFilesForSession(openFiles(), session);
+
+            session.clearMessages();
+            for (const expected of expectedGetErrForProject()) {
+                const expectedSequenceId = session.getNextSeq();
+                session.executeCommandSeq<protocol.GeterrForProjectRequest>({
+                    command: protocol.CommandTypes.GeterrForProject,
+                    arguments: {
+                        delay: 0,
+                        file: expected.project
+                    }
+                });
+
+                checkAllErrors({ session, host, expected: expected.errors, expectedSequenceId });
+            }
+        });
+    }
+
+    function verifyErrorsUsingSyncMethods({ allFiles, openFiles, expectedSyncDiagnostics }: VerifyGetErrScenario) {
+        it("verifies the errors using sync commands", () => {
+            const host = createServerHost([...allFiles(), libFile]);
+            const session = createSession(host);
+            openFilesForSession(openFiles(), session);
+            for (const { file, project, syntax, semantic, suggestion } of expectedSyncDiagnostics()) {
+                const actualSyntax = session.executeCommandSeq<protocol.SyntacticDiagnosticsSyncRequest>({
+                    command: protocol.CommandTypes.SyntacticDiagnosticsSync,
+                    arguments: {
+                        file: filePath(file),
+                        projectFileName: project
+                    }
+                }).response as protocol.Diagnostic[];
+                assert.deepEqual(actualSyntax, syntax, `Syntax diagnostics for file: ${filePath(file)}, project: ${project}`);
+                const actualSemantic = session.executeCommandSeq<protocol.SemanticDiagnosticsSyncRequest>({
+                    command: protocol.CommandTypes.SemanticDiagnosticsSync,
+                    arguments: {
+                        file: filePath(file),
+                        projectFileName: project
+                    }
+                }).response as protocol.Diagnostic[];
+                assert.deepEqual(actualSemantic, semantic, `Semantic diagnostics for file: ${filePath(file)}, project: ${project}`);
+                const actualSuggestion = session.executeCommandSeq<protocol.SuggestionDiagnosticsSyncRequest>({
+                    command: protocol.CommandTypes.SuggestionDiagnosticsSync,
+                    arguments: {
+                        file: filePath(file),
+                        projectFileName: project
+                    }
+                }).response as protocol.Diagnostic[];
+                assert.deepEqual(actualSuggestion, suggestion, `Suggestion diagnostics for file: ${filePath(file)}, project: ${project}`);
+            }
+        });
+    }
+
+    function verifyConfigFileErrors({ allFiles, openFiles, expectedConfigFileDiagEvents }: VerifyGetErrScenario) {
+        it("verify config file errors", () => {
+            const host = createServerHost([...allFiles(), libFile]);
+            const { session, events } = createSessionWithEventTracking<server.ConfigFileDiagEvent>(host, server.ConfigFileDiagEvent);
+
+            for (const file of openFiles()) {
+                session.executeCommandSeq<protocol.OpenRequest>({
+                    command: protocol.CommandTypes.Open,
+                    arguments: { file: file.path }
+                });
+            }
+
+            assert.deepEqual(events, expectedConfigFileDiagEvents().map(data => ({
+                eventName: server.ConfigFileDiagEvent,
+                data
+            })));
+        });
+    }
+
+    export interface GetErrForProjectDiagnostics {
+        project: string;
+        errors: readonly GetErrDiagnostics[];
+    }
+    export interface SyncDiagnostics extends GetErrDiagnostics {
+        project?: string;
+    }
+    export interface VerifyGetErrScenario {
+        allFiles: () => readonly File[];
+        openFiles: () => readonly File[];
+        expectedGetErr: () => readonly GetErrDiagnostics[];
+        expectedGetErrForProject: () => readonly GetErrForProjectDiagnostics[];
+        expectedSyncDiagnostics: () => readonly SyncDiagnostics[];
+        expectedConfigFileDiagEvents: () => readonly server.ConfigFileDiagEvent["data"][];
+    }
+    export function verifyGetErrScenario(scenario: VerifyGetErrScenario) {
+        verifyErrorsUsingGeterr(scenario);
+        verifyErrorsUsingGeterrForProject(scenario);
+        verifyErrorsUsingSyncMethods(scenario);
+        verifyConfigFileErrors(scenario);
+    }
+
+    export function emptyDiagnostics(file: File): GetErrDiagnostics {
+        return {
+            file,
+            syntax: emptyArray,
+            semantic: emptyArray,
+            suggestion: emptyArray
+        };
+    }
+
+    export function syncDiagnostics(diagnostics: GetErrDiagnostics, project: string): SyncDiagnostics {
+        return { project, ...diagnostics };
+    }
 }

src/testRunner/unittests/tsserver/projectErrors.ts

@@ -493,6 +493,48 @@ declare module '@custom/plugin' {
                 });
             }
         });
+
+        describe("when semantic error returns includes global error", () => {
+            const file: File = {
+                path: `${tscWatch.projectRoot}/ui.ts`,
+                content: `const x = async (_action: string) => {
+};`
+            };
+            const config: File = {
+                path: `${tscWatch.projectRoot}/tsconfig.json`,
+                content: "{}"
+            };
+            function expectedDiagnostics(): GetErrDiagnostics {
+                const span = protocolTextSpanFromSubstring(file.content, `async (_action: string) => {`);
+                return {
+                    file,
+                    syntax: [],
+                    semantic: [
+                        createDiagnostic(span.start, span.end, Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option, [], "error"),
+                    ],
+                    suggestion: []
+                };
+            }
+            verifyGetErrScenario({
+                allFiles: () => [libFile, file, config],
+                openFiles: () => [file],
+                expectedGetErr: () => [expectedDiagnostics()],
+                expectedGetErrForProject: () => [{
+                    project: file.path,
+                    errors: [
+                        expectedDiagnostics(),
+                    ]
+                }],
+                expectedSyncDiagnostics: () => [
+                    syncDiagnostics(expectedDiagnostics(), config.path),
+                ],
+                expectedConfigFileDiagEvents: () => [{
+                    triggerFile: file.path,
+                    configFileName: config.path,
+                    diagnostics: emptyArray
+                }]
+            });
+        });
     });
 
     describe("unittests:: tsserver:: Project Errors for Configure file diagnostics events", () => {