Fix massive performance regression for projects using correct module graphs

src/project-roots.ts

@@ -87,6 +87,10 @@ export default class ProjectRoots {
       ignore: ['**/.git/**', '**/bower_components/**', '**/dist/**', '**/node_modules/**', '**/tmp/**'],
     });
 
+    logInfo(`ELS: Found ${roots.length} roots for ${workspaceRoot}`);
+
+    const start = Date.now();
+
     for (const rootPath of roots) {
       const filePath = path.join(workspaceRoot, rootPath);
       const fullPath = path.dirname(filePath);
@@ -103,6 +107,8 @@ export default class ProjectRoots {
         await this.onProjectAdd(fullPath);
       }
     }
+
+    logInfo(`ELS: iterating roots took ${Date.now() - start}ms`);
   }
 
   async initialize(workspaceRoot: string) {
@@ -122,6 +128,8 @@ export default class ProjectRoots {
     if (this.projects.has(projectPath)) {
       const project = this.projects.get(projectPath) as Project;
 
+      logInfo(`Project already existed at ${projectPath}`);
+
       return {
         initIssues: project.initIssues,
         providers: project.providers,
@@ -154,12 +162,16 @@ export default class ProjectRoots {
         };
       }
 
+      logInfo(`Initializing new project at ${projectPath} with ${this.localAddons.length} ELS addons.`);
+
       const project = new Project(projectPath, this.localAddons, info);
 
+      const start = Date.now();
+
       await project.initialize(this.server);
 
       this.projects.set(projectPath, project);
-      logInfo(`Ember CLI project added at ${projectPath}`);
+      logInfo(`Ember CLI project added at ${projectPath}. (took ${Date.now() - start}ms)`);
       await project.init(this.server);
 
       return {

src/server.ts

@@ -168,12 +168,14 @@ export default class Server {
   hoverProvider!: HoverProvider;
   codeActionProvider!: CodeActionProvider;
   async executeInitializers() {
-    logInfo('UELS: executeInitializers');
+    logInfo('ELS: executeInitializers');
+    logInfo(`ELS: ${this.initializers.length} initializers`);
 
     for (const initializer of this.initializers) {
       await initializer();
     }
 
+    logInfo(`ELS: clearing initializers because they've been initialized`);
     this.initializers = [];
   }
   private onInitialized() {
@@ -190,6 +192,10 @@ export default class Server {
 
       if (this.lazyInit) {
         try {
+          /**
+           * Don't await this so that "format on save" is not blocked.
+           * We still need to run the initializers so that we have hinting in component files though.
+           */
           await this.executeInitializers();
         } catch (e) {
           logError(e);
@@ -524,6 +530,8 @@ export default class Server {
     this.initializers.push(async () => {
       await this.projectRoots.initialize(rootPath as string);
 
+      logInfo(`Found ${workspaceFolders?.length ?? 0} workspace folders for ${rootPath}`);
+
       if (workspaceFolders && Array.isArray(workspaceFolders)) {
         for (const folder of workspaceFolders) {
           const folderPath = URI.parse(folder.uri).fsPath;

src/utils/addon-api.ts

@@ -11,7 +11,7 @@ import {
 } from './layout-helpers';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import * as path from 'path';
-import { log, logInfo, logError, safeStringify } from './logger';
+import { log, logInfo, logError, safeStringify, instrumentTime } from './logger';
 import Server from '../server';
 import ASTPath from './../glimmer-utils';
 import DAGMap from 'dag-map';
@@ -188,7 +188,13 @@ function requireUncached(module: string) {
 }
 
 export async function collectProjectProviders(root: string, addons: string[]): Promise<ProjectProviders> {
+  const time = instrumentTime(`collectProjectProviders(${root})`);
+
+  time.log(`Starting`);
   const [projectAddonsRoots, projectInRepoAddonsRoots] = await Promise.all([getProjectAddonsRoots(root), getProjectInRepoAddonsRoots(root)]);
+
+  time.log(`found roots`);
+
   const roots = addons
     .concat([root])
     .concat(projectAddonsRoots, projectInRepoAddonsRoots)
@@ -226,6 +232,8 @@ export async function collectProjectProviders(root: string, addons: string[]): P
     }
   }
 
+  time.log(`found ELS addons`);
+
   const result: {
     definitionProviders: DefinitionResolveFunction[];
     referencesProviders: ReferenceResolveFunction[];
@@ -332,6 +340,8 @@ export async function collectProjectProviders(root: string, addons: string[]): P
     }
   });
 
+  time.log(`finished crawling dagMap`);
+
   return result;
 }
 

src/utils/layout-helpers.ts

@@ -6,9 +6,14 @@ import { clean, coerce, valid } from 'semver';
 import { BaseProject } from '../base-project';
 import { fsProvider } from '../fs-provider';
 import walkAsync from './walk-async';
+import { instrumentTime } from './logger';
 
 // const GLOBAL_REGISTRY = ['primitive-name'][['relatedFiles']];
 
+// Don't traverse dependencies we've already seen.
+// correct package graph can sort of throw us in to cycles if we don't keep track of this.
+const SEEN = new Set<string>();
+
 export const ADDON_CONFIG_KEY = 'ember-language-server';
 
 export async function asyncFilter<T>(arr: T[], predicate: (value: unknown) => Promise<boolean | undefined>): Promise<T[]> {
@@ -196,6 +201,16 @@ export function cached(_proto: unknown, prop: string, desc: PropertyDescriptor)
 
 async function getRecursiveInRepoAddonRoots(root: string, roots: string[]) {
   const packageData = await asyncGetPackageJSON(root);
+
+  // names are required for packages
+  if (!packageData.name) return [];
+
+  if (SEEN.has(packageData.name)) {
+    return [];
+  }
+
+  SEEN.add(packageData.name);
+
   const emberAddonPaths: string[] = (packageData['ember-addon'] && packageData['ember-addon'].paths) || [];
 
   if (roots.length) {
@@ -213,6 +228,15 @@ async function getRecursiveInRepoAddonRoots(root: string, roots: string[]) {
   for (const validRoot of validPaths) {
     const packInfo = await asyncGetPackageJSON(validRoot);
 
+    // names are required for packages
+    if (!packInfo.name) continue;
+
+    if (SEEN.has(packInfo.name)) {
+      continue;
+    }
+
+    SEEN.add(packInfo.name);
+
     // we don't need to go deeper if package itself not an ember-addon or els-extension
     if (!isEmberAddon(packInfo) && !hasEmberLanguageServerExtension(packInfo)) {
       continue;
@@ -234,8 +258,12 @@ async function getRecursiveInRepoAddonRoots(root: string, roots: string[]) {
 }
 
 export async function getProjectInRepoAddonsRoots(root: string): Promise<string[]> {
+  const time = instrumentTime(`getProjectInRepoAddonsRoots(${root})`);
+
   const roots: string[] = await getRecursiveInRepoAddonRoots(root, []);
 
+  time.log(`finished getRecursiveInRepoAddonRoots`);
+
   return Array.from(new Set(roots));
 }
 
@@ -274,8 +302,16 @@ export async function isGlimmerXProject(root: string) {
 }
 
 export async function getProjectAddonsRoots(root: string, resolvedItems: string[] = [], packageFolderName = 'node_modules') {
+  const time = instrumentTime(`getProjectInRepoAddonsRoots(${root})`);
+
   const pack = await asyncGetPackageJSON(root);
 
+  if (!pack.name) return [];
+
+  if (SEEN.has(pack.name)) return [];
+
+  SEEN.add(pack.name);
+
   if (resolvedItems.length) {
     if (!isEmberAddon(pack)) {
       return [];
@@ -304,6 +340,12 @@ export async function getProjectAddonsRoots(root: string, resolvedItems: string[
   for (const rootItem of roots) {
     const packInfo = packages[roots.indexOf(rootItem)];
 
+    if (!packInfo.name) continue;
+
+    if (SEEN.has(packInfo.name)) continue;
+
+    SEEN.add(packInfo.name);
+
     // we don't need to go deeper if package itself not an ember-addon or els-extension
     if (!isEmberAddon(packInfo) && !hasEmberLanguageServerExtension(packInfo)) {
       continue;
@@ -321,6 +363,8 @@ export async function getProjectAddonsRoots(root: string, resolvedItems: string[
     }
   }
 
+  time.log(`Finished looping over ${roots.length} roots`);
+
   return recursiveRoots;
 }
 

src/utils/logger.ts

@@ -35,6 +35,24 @@ export function logInfo(str: string) {
   }
 }
 
+export function instrumentTime(label: string) {
+  let last = Date.now();
+
+  return {
+    reset: () => {
+      last = Date.now();
+    },
+    log: (msg: string) => {
+      const now = Date.now();
+      const diff = now - last;
+
+      last = now;
+
+      logInfo(`[${label}] +${diff}ms :: ${msg}`);
+    },
+  };
+}
+
 export function setConsole(item: RemoteConsole | null) {
   remoteConsole = item;
 }

test/__snapshots__/integration-test.ts.snap

@@ -7339,6 +7339,37 @@ Object {
 }
 `;
 
+exports[`integration async fs enabled: true Go to definition works for all supported cases to children route from application outlet 2`] = `
+Object {
+  "addonsMeta": Array [],
+  "registry": Object {
+    "routePath": Object {
+      "application": Array [
+        "app/templates/application.hbs",
+      ],
+      "foo": Array [
+        "app/templates/foo.hbs",
+      ],
+    },
+  },
+  "response": Array [
+    Object {
+      "range": Object {
+        "end": Object {
+          "character": 0,
+          "line": 0,
+        },
+        "start": Object {
+          "character": 0,
+          "line": 0,
+        },
+      },
+      "uri": "/app/templates/foo.hbs",
+    },
+  ],
+}
+`;
+
 exports[`integration async fs enabled: true Go to definition works for all supported cases to children route from meaningful outlet 1`] = `
 Object {
   "addonsMeta": Array [],