Add needDefaultProjectInfo to get details about the default project for file

Author: sheetalkamat

src/server/editorServices.ts

@@ -713,6 +713,8 @@ function isAncestorConfigFileInfo(infoOrFileNameOrConfig: OpenScriptInfoOrClosed
 export enum ConfiguredProjectLoadKind {
     FindOptimized,
     Find,
+    CreateReplayOptimized,
+    CreateReplay,
     CreateOptimized,
     Create,
     ReloadOptimized,
@@ -721,11 +723,13 @@ export enum ConfiguredProjectLoadKind {
 
 type ConguredProjectLoadFindCreateOrReload =
     | ConfiguredProjectLoadKind.Find
+    | ConfiguredProjectLoadKind.CreateReplay
     | ConfiguredProjectLoadKind.Create
     | ConfiguredProjectLoadKind.Reload;
 
 type ConguredProjectLoadFindCreateOrReloadOptimized =
     | ConfiguredProjectLoadKind.FindOptimized
+    | ConfiguredProjectLoadKind.CreateReplayOptimized
     | ConfiguredProjectLoadKind.CreateOptimized
     | ConfiguredProjectLoadKind.ReloadOptimized;
 
@@ -753,6 +757,18 @@ export interface FindCreateOrLoadConfiguredProjectResult {
     reason: string | undefined;
 }
 
+/** @internal */
+export interface DefaultConfiguredProjectInfo {
+    /** List of config files looked and did not match because file was not part of root file names */
+    notMatchedByConfig?: Set<NormalizedPath>;
+    /** List of projects which were loaded but file was not part of the project */
+    notInProject?: Set<ConfiguredProject>;
+    /** List of projects where file was present in project but its a file from referenced project */
+    inProjectWithReference?: Set<ConfiguredProject>;
+    /** Configured project used as default */
+    defaultProject?: ConfiguredProject;
+}
+
 /**
  * Goes through each tsconfig from project till project root of open script info and finds, creates or reloads project per kind
  */
@@ -794,8 +810,7 @@ function forEachAncestorProjectLoad<T>(
                 configFileInfo: true,
                 isForDefaultProject: !searchOnlyPotentialSolution,
             },
-            kind === ConfiguredProjectLoadKind.Find ||
-                kind === ConfiguredProjectLoadKind.FindOptimized,
+            kind <= ConfiguredProjectLoadKind.CreateReplay,
         );
         if (!configFileName) return;
 
@@ -865,21 +880,28 @@ function forEachResolvedProjectReferenceProjectLoad<T>(
                 configFileExistenceInfo?.exists || project.resolvedChildConfigs?.has(childCanonicalConfigPath) ?
                     configFileExistenceInfo!.config!.parsedCommandLine : undefined :
                 project.getParsedCommandLine(childConfigName);
-            if (childConfig && loadKind !== kind) {
+            if (childConfig && loadKind !== kind && loadKind > ConfiguredProjectLoadKind.CreateReplayOptimized) {
                 // If this was found using find: ensure this is uptodate if looking for creating or reloading
                 childConfig = project.getParsedCommandLine(childConfigName);
             }
             if (!childConfig) return undefined;
 
             // Find the project
             const childProject = project.projectService.findConfiguredProjectByProjectName(childConfigName, allowDeferredClosed);
+            // Ignore if we couldnt find child project or config file existence info
+            if (
+                loadKind === ConfiguredProjectLoadKind.CreateReplayOptimized &&
+                !configFileExistenceInfo &&
+                !childProject
+            ) return undefined;
             switch (loadKind) {
                 case ConfiguredProjectLoadKind.ReloadOptimized:
                     if (childProject) childProject.projectService.reloadConfiguredProjectOptimized(childProject, reason, reloadedProjects!);
                     // falls through
                 case ConfiguredProjectLoadKind.CreateOptimized:
                     (project.resolvedChildConfigs ??= new Set()).add(childCanonicalConfigPath);
-                    // falls through
+                // falls through
+                case ConfiguredProjectLoadKind.CreateReplayOptimized:
                 case ConfiguredProjectLoadKind.FindOptimized:
                     if (childProject || loadKind !== ConfiguredProjectLoadKind.FindOptimized) {
                         const result = cb(
@@ -930,6 +952,12 @@ function updateProjectFoundUsingFind(
     // This project was found using "Find" instead of the actually specified kind of "Create" or "Reload",
     // We need to update or reload this existing project before calling callback
     switch (kind) {
+        case ConfiguredProjectLoadKind.CreateReplayOptimized:
+        case ConfiguredProjectLoadKind.CreateReplay:
+            if (useConfigFileExistenceInfoForOptimizedLoading(project)) {
+                configFileExistenceInfo = project.projectService.configFileExistenceInfoCache.get(project.canonicalConfigFilePath)!;
+            }
+            break;
         case ConfiguredProjectLoadKind.CreateOptimized:
             configFileExistenceInfo = configFileExistenceInfoForOptimizedLoading(project);
             if (configFileExistenceInfo) break;
@@ -1077,9 +1105,21 @@ function configFileExistenceInfoForOptimizedLoading(project: ConfiguredProject)
     project.resolvedChildConfigs = undefined;
     project.updateReferences(parsedCommandLine.projectReferences);
     // Composite can determine based on files themselves, no need to load project
-    if (parsedCommandLine.options.composite) return configFileExistenceInfo;
     // If solution, no need to load it to determine if file belongs to it
-    if (isSolutionConfig(parsedCommandLine)) return configFileExistenceInfo;
+    if (useConfigFileExistenceInfoForOptimizedLoading(project)) return configFileExistenceInfo;
+}
+
+function useConfigFileExistenceInfoForOptimizedLoading(project: ConfiguredProject) {
+    return !!project.parsedCommandLine &&
+        (!!project.parsedCommandLine.options.composite ||
+            // If solution, no need to load it to determine if file belongs to it
+            !!isSolutionConfig(project.parsedCommandLine));
+}
+
+function configFileExistenceInfoForOptimizedReplay(project: ConfiguredProject) {
+    return useConfigFileExistenceInfoForOptimizedLoading(project) ?
+        project.projectService.configFileExistenceInfoCache.get(project.canonicalConfigFilePath)! :
+        undefined;
 }
 
 function fileOpenReason(info: ScriptInfo) {
@@ -2603,11 +2643,26 @@ export class ProjectService {
 
     /** @internal */
     findDefaultConfiguredProject(info: ScriptInfo) {
+        return this.findDefaultConfiguredProjectWorker(
+            info,
+            ConfiguredProjectLoadKind.Find,
+        )?.defaultProject;
+    }
+
+    /** @internal */
+    findDefaultConfiguredProjectWorker(
+        info: ScriptInfo,
+        kind: ConfiguredProjectLoadKind.Find | ConfiguredProjectLoadKind.CreateReplay,
+        replayResult?: DefaultConfiguredProjectInfo,
+    ) {
         return info.isScriptOpen() ?
             this.tryFindDefaultConfiguredProjectForOpenScriptInfo(
                 info,
-                ConfiguredProjectLoadKind.Find,
-            )?.defaultProject :
+                kind,
+                /*allowDeferredClosed*/ undefined,
+                /*reloadedProjects*/ undefined,
+                replayResult,
+            ) :
             undefined;
     }
 
@@ -4360,7 +4415,12 @@ export class ProjectService {
         switch (kind) {
             case ConfiguredProjectLoadKind.FindOptimized:
             case ConfiguredProjectLoadKind.Find:
+            case ConfiguredProjectLoadKind.CreateReplay:
+                if (!project) return;
+                break;
+            case ConfiguredProjectLoadKind.CreateReplayOptimized:
                 if (!project) return;
+                configFileExistenceInfo = configFileExistenceInfoForOptimizedReplay(project);
                 break;
             case ConfiguredProjectLoadKind.CreateOptimized:
             case ConfiguredProjectLoadKind.Create:
@@ -4413,8 +4473,10 @@ export class ProjectService {
         allowDeferredClosed?: boolean,
         /** Used with ConfiguredProjectLoadKind.Reload to check if this project was already reloaded */
         reloadedProjects?: ConfiguredProjectToAnyReloadKind,
+        /** Used with ConfiguredProjectLoadKind.CreateReplay to store replay result */
+        replayResult?: DefaultConfiguredProjectInfo,
     ): DefaultConfiguredProjectResult | undefined {
-        const configFileName = this.getConfigFileNameForFile(info, kind === ConfiguredProjectLoadKind.Find);
+        const configFileName = this.getConfigFileNameForFile(info, kind <= ConfiguredProjectLoadKind.CreateReplay);
         // If no config file name, no result
         if (!configFileName) return;
 
@@ -4437,6 +4499,7 @@ export class ProjectService {
             project => `Creating project referenced in solution ${project.projectName} to find possible configured project for ${info.fileName} to open`,
             allowDeferredClosed,
             reloadedProjects,
+            replayResult,
         );
     }
 
@@ -4491,6 +4554,8 @@ export class ProjectService {
         allowDeferredClosed?: boolean,
         /** Used with ConfiguredProjectLoadKind.Reload to check if this project was already reloaded */
         reloadedProjects?: ConfiguredProjectToAnyReloadKind,
+        /** Used with ConfiguredProjectLoadKind.CreateReplay to store replay result */
+        replayResult?: DefaultConfiguredProjectInfo,
     ) {
         const infoIsOpenScriptInfo = isOpenScriptInfo(info);
         const optimizedKind = toConfiguredProjectLoadOptimized(kind);
@@ -4503,14 +4568,18 @@ export class ProjectService {
         let tsconfigOfPossiblyDefault: ConfiguredProject | undefined;
         // See if this is the project or is it one of the references or find ancestor projects
         tryFindDefaultConfiguredProject(initialConfigResult);
+        const result = defaultProject ?? possiblyDefault;
+        if (replayResult) replayResult.defaultProject = result;
         return {
-            defaultProject: defaultProject ?? possiblyDefault,
+            defaultProject: result,
             tsconfigProject: tsconfigOfDefault ?? tsconfigOfPossiblyDefault,
             sentConfigDiag,
             seenProjects,
         };
 
-        function tryFindDefaultConfiguredProject(result: FindCreateOrLoadConfiguredProjectResult): ConfiguredProject | undefined {
+        function tryFindDefaultConfiguredProject(
+            result: FindCreateOrLoadConfiguredProjectResult,
+        ): ConfiguredProject | undefined {
             return isDefaultProjectOptimized(result, result.project) ??
                 tryFindDefaultConfiguredProjectFromReferences(result.project) ??
                 tryFindDefaultConfiguredProjectFromAncestor(result.project);
@@ -4542,7 +4611,8 @@ export class ProjectService {
                     info,
                 )
             ) {
-                if (tsconfigProject.languageServiceEnabled) {
+                if (replayResult) (replayResult.notMatchedByConfig ??= new Set()).add(childConfigName);
+                else if (tsconfigProject.languageServiceEnabled) {
                     // Ensure we are watching the parsedCommandLine
                     tsconfigProject.projectService.watchWildcards(
                         childConfigName,
@@ -4569,7 +4639,12 @@ export class ProjectService {
                     allowDeferredClosed,
                     info.fileName,
                     reloadedProjects,
-                )!;
+                );
+            if (!result) {
+                // Did no find existing project but thats ok, we will give information based on what we find
+                Debug.assert(replayResult);
+                return undefined;
+            }
             seenProjects.set(result.project, optimizedKind);
             if (result.sentConfigFileDiag) sentConfigDiag.add(result.project);
             return isDefaultProject(result.project, tsconfigProject);
@@ -4589,6 +4664,10 @@ export class ProjectService {
                 tsconfigOfDefault = tsconfigProject;
                 return defaultProject = project;
             }
+            if (replayResult) {
+                if (!projectWithInfo) (replayResult.notInProject ??= new Set()).add(project);
+                else (replayResult.inProjectWithReference ??= new Set()).add(project);
+            }
             // If this project uses the script info, if default project is not found, use this project as possible default
             if (!possiblyDefault && infoIsOpenScriptInfo && projectWithInfo) {
                 tsconfigOfPossiblyDefault = tsconfigProject;
@@ -4658,7 +4737,7 @@ export class ProjectService {
     ): DefaultConfiguredProjectResult | undefined;
     private tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
         info: ScriptInfo,
-        kind: ConguredProjectLoadFindCreateOrReload,
+        kind: ConfiguredProjectLoadKind.Find | ConfiguredProjectLoadKind.Create | ConfiguredProjectLoadKind.Reload,
         reloadedProjects?: ConfiguredProjectToAnyReloadKind,
         delayReloadedConfiguredProjects?: Set<ConfiguredProject>,
     ): DefaultConfiguredProjectResult | undefined {

src/server/protocol.ts

@@ -498,6 +498,10 @@ export interface ProjectInfoRequestArgs extends FileRequestArgs {
      * Indicate if the file name list of the project is needed
      */
     needFileNameList: boolean;
+    /**
+     * if true returns details about default configured project calculation
+     */
+    needDefaultConfiguredProjectInfo?: boolean;
 }
 
 /**
@@ -525,6 +529,20 @@ export interface CompilerOptionsDiagnosticsRequestArgs {
     projectFileName: string;
 }
 
+/**
+ * Details about the default project for the file
+ */
+export interface DefaultConfiguredProjectInfo {
+    /** List of config files looked and did not match because file was not part of root file names */
+    notMatchedByConfig?: readonly string[];
+    /** List of projects which were loaded but file was not part of the project */
+    notInProject?: readonly string[];
+    /** List of projects where file was present in project but its a file from referenced project */
+    inProjectWithReference?: readonly string[];
+    /** Configured project used as default */
+    defaultProject?: string;
+}
+
 /**
  * Response message body for "projectInfo" request
  */
@@ -542,6 +560,10 @@ export interface ProjectInfo {
      * Indicates if the project has a active language service instance
      */
     languageServiceDisabled?: boolean;
+    /**
+     * Information about default project
+     */
+    configuredProjectInfo?: DefaultConfiguredProjectInfo;
 }
 
 /**

src/server/session.ts

@@ -143,11 +143,13 @@ import {
     CloseFileWatcherEvent,
     ConfigFileDiagEvent,
     ConfiguredProject,
+    ConfiguredProjectLoadKind,
     convertFormatOptions,
     convertScriptKindName,
     convertUserPreferences,
     CreateDirectoryWatcherEvent,
     CreateFileWatcherEvent,
+    DefaultConfiguredProjectInfo,
     EmitResult,
     emptyArray,
     Errors,
@@ -2039,20 +2041,53 @@ export class Session<TMessage = string> implements EventSender {
     }
 
     private getProjectInfo(args: protocol.ProjectInfoRequestArgs): protocol.ProjectInfo {
-        return this.getProjectInfoWorker(args.file, args.projectFileName, args.needFileNameList, /*excludeConfigFiles*/ false);
+        return this.getProjectInfoWorker(
+            args.file,
+            args.projectFileName,
+            args.needFileNameList,
+            args.needDefaultConfiguredProjectInfo,
+            /*excludeConfigFiles*/ false,
+        );
     }
 
-    private getProjectInfoWorker(uncheckedFileName: string, projectFileName: string | undefined, needFileNameList: boolean, excludeConfigFiles: boolean) {
+    private getProjectInfoWorker(
+        uncheckedFileName: string,
+        projectFileName: string | undefined,
+        needFileNameList: boolean,
+        needDefaultConfiguredProjectInfo: boolean | undefined,
+        excludeConfigFiles: boolean,
+    ): Omit<protocol.ProjectInfo, "fileNames"> & { fileNames?: NormalizedPath[]; } {
         const { project } = this.getFileAndProjectWorker(uncheckedFileName, projectFileName);
         updateProjectIfDirty(project);
         const projectInfo = {
             configFileName: project.getProjectName(),
             languageServiceDisabled: !project.languageServiceEnabled,
             fileNames: needFileNameList ? project.getFileNames(/*excludeFilesFromExternalLibraries*/ false, excludeConfigFiles) : undefined,
+            configuredProjectInfo: needDefaultConfiguredProjectInfo ? this.getDefaultConfiguredProjectInfo(uncheckedFileName) : undefined,
         };
         return projectInfo;
     }
 
+    private getDefaultConfiguredProjectInfo(uncheckedFileName: string): protocol.DefaultConfiguredProjectInfo | undefined {
+        const info = this.projectService.getScriptInfo(uncheckedFileName);
+        if (!info) return;
+
+        // Find default project for the info
+        const replayResult: DefaultConfiguredProjectInfo = {};
+        this.projectService.findDefaultConfiguredProjectWorker(
+            info,
+            ConfiguredProjectLoadKind.CreateReplay,
+            replayResult,
+        );
+        const configName = (project: ConfiguredProject) => toNormalizedPath(project.getConfigFilePath());
+        return {
+            notMatchedByConfig: replayResult.notMatchedByConfig && arrayFrom(replayResult.notMatchedByConfig),
+            notInProject: replayResult.notInProject && arrayFrom(mapIterator(replayResult.notInProject, configName)),
+            inProjectWithReference: replayResult.inProjectWithReference && arrayFrom(mapIterator(replayResult.inProjectWithReference, configName)),
+            defaultProject: replayResult.defaultProject && configName(replayResult.defaultProject),
+        };
+    }
+
     private getRenameInfo(args: protocol.FileLocationRequestArgs): RenameInfo {
         const { file, project } = this.getFileAndProject(args);
         const position = this.getPositionInFile(args, file);
@@ -3094,16 +3129,19 @@ export class Session<TMessage = string> implements EventSender {
             return;
         }
 
-        const { fileNames, languageServiceDisabled } = this.getProjectInfoWorker(fileName, /*projectFileName*/ undefined, /*needFileNameList*/ true, /*excludeConfigFiles*/ true);
-        if (languageServiceDisabled) {
-            return;
-        }
+        const { fileNames, languageServiceDisabled } = this.getProjectInfoWorker(
+            fileName,
+            /*projectFileName*/ undefined,
+            /*needFileNameList*/ true,
+            /*needDefaultConfiguredProjectInfo*/ undefined,
+            /*excludeConfigFiles*/ true,
+        );
+
+        if (languageServiceDisabled) return;
 
         // No need to analyze lib.d.ts
         const fileNamesInProject = fileNames!.filter(value => !value.includes("lib.d.ts")); // TODO: GH#18217
-        if (fileNamesInProject.length === 0) {
-            return;
-        }
+        if (fileNamesInProject.length === 0) return;
 
         // Sort the file name list to make the recently touched files come first
         const highPriorityFiles: NormalizedPath[] = [];