perf: rework snapshot hot paths

This function was originally using `replace` to unix-ify paths before
then testing against them with `endsWith`.

We can instead use static patterns on the unaltered path regardless of
separator.

This was originally using `split` to "parse" the cache key into a
file/specifier pair.

We don't actually need to do this as we know there's always one
occurrence of `CACHE_KEY_SEPARATOR`. So we can instead just `slice` on
the index of the separator.

Additionally, we only compute any of this the first time we encounter an
unresolved cache entry.

I then noticed that `fileNameWithoutEnding` could be `a` (from
`a.svelte`), for example. This then meant we would delete all cache
entries with specifiers containing `a` (since we did
`specifier.includes(fileNameWithoutEnding)`).

I have changed this to explicitly test for these two cases instead:

- Exact match (i.e. the specifier is exactly `fileNameWithoutEnding`)
- Path-like string includes specifier (`/{fileNameWithoutEnding}.`)

For example, `a.svelte` would become `a`. We then want to check for
`/a.` to be able to match `/a.svelte`, `/a.svelte.js`, etc. Nobody can
import it without a `/` preceding it since then it'd be a bare
specifier.

We currently key by file name and specifier.

It shouldn't be possible for two sibling files to resolve the same specifier
to two different modules.

So it seems like we should be able to key by `dirname(path)` instead.
This means we would cache resolution for entire directories rather than
re-computing it for every file in that directory.

This now uses `slice` on the last separator rather than splitting only
to retrieve the last part.

Author: 43081j

packages/language-server/src/plugins/typescript/DocumentSnapshot.ts

@@ -73,6 +73,12 @@ export interface SvelteSnapshotOptions {
     typingsNamespace: string;
 }
 
+const ambientPathPattern = /node_modules[\/\\]svelte[\/\\]types[\/\\]ambient\.d\.ts$/;
+const svelteTypesPattern = /node_modules[\/\\]svelte[\/\\]types[\/\\]index\.d\.ts$/;
+const shimsPattern =
+    /svelte2tsx[\/\\]svelte-shims\.d\.ts$|svelte-check[\/\\]dist[\/\\]src[\/\\]svelte-shims\.d\.ts$/;
+
+
 export namespace DocumentSnapshot {
     /**
      * Returns a svelte snapshot from a svelte document.
@@ -121,30 +127,25 @@ export namespace DocumentSnapshot {
      * @param options options that apply in case it's a svelte file
      */
     export function fromNonSvelteFilePath(filePath: string, tsSystem: ts.System) {
-        let originalText = '';
-
         // The following (very hacky) code makes sure that the ambient module definitions
         // that tell TS "every import ending with .svelte is a valid module" are removed.
         // They exist in svelte2tsx and svelte to make sure that people don't
         // get errors in their TS files when importing Svelte files and not using our TS plugin.
         // If someone wants to get back the behavior they can add an ambient module definition
         // on their own.
-        const normalizedPath = filePath.replace(/\\/g, '/');
-        if (!normalizedPath.endsWith('node_modules/svelte/types/runtime/ambient.d.ts')) {
+        let originalText = '';
+        if (!ambientPathPattern.test(filePath)) {
             originalText = tsSystem.readFile(filePath) || '';
         }
 
-        if (normalizedPath.endsWith('node_modules/svelte/types/index.d.ts')) {
+        if (svelteTypesPattern.test(filePath)) {
             const startIdx = originalText.indexOf(`declare module '*.svelte' {`);
             const endIdx = originalText.indexOf(`\n}`, startIdx + 1) + 2;
             originalText =
                 originalText.substring(0, startIdx) +
                 ' '.repeat(endIdx - startIdx) +
                 originalText.substring(endIdx);
-        } else if (
-            normalizedPath.endsWith('svelte2tsx/svelte-shims.d.ts') ||
-            normalizedPath.endsWith('svelte-check/dist/src/svelte-shims.d.ts')
-        ) {
+        } else if (shimsPattern.test(filePath)) {
             // If not present, the LS uses an older version of svelte2tsx
             if (originalText.includes('// -- start svelte-ls-remove --')) {
                 originalText =
@@ -157,7 +158,7 @@ export namespace DocumentSnapshot {
         }
 
         const declarationExtensions = [ts.Extension.Dcts, ts.Extension.Dts, ts.Extension.Dmts];
-        if (declarationExtensions.some((ext) => normalizedPath.endsWith(ext))) {
+        if (declarationExtensions.some((ext) => filePath.endsWith(ext))) {
             return new DtsDocumentSnapshot(INITIAL_VERSION, filePath, originalText, tsSystem);
         }
 

packages/language-server/src/plugins/typescript/module-loader.ts

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import path from 'node:path';
 import { FileMap, FileSet } from '../../lib/documents/fileCollection';
 import { createGetCanonicalFileName, getLastPartOfPath, toFileNameLowerCase } from '../../utils';
 import { DocumentSnapshot } from './DocumentSnapshot';
@@ -60,22 +61,36 @@ class ModuleResolutionCache {
      * and which might match the path.
      */
     deleteUnresolvedResolutionsFromCache(path: string): void {
-        const fileNameWithoutEnding =
-            getLastPartOfPath(this.getCanonicalFileName(path)).split('.').shift() || '';
+        let fileNameWithoutEnding: string | undefined;
         this.cache.forEach((val, key) => {
             if (val) {
                 return;
             }
-            const [containingFile, moduleName = ''] = key.split(CACHE_KEY_SEPARATOR);
-            if (moduleName.includes(fileNameWithoutEnding)) {
+            if (fileNameWithoutEnding === undefined) {
+                const canonicalPath = this.getCanonicalFileName(path);
+                const lastPart = getLastPartOfPath(canonicalPath);
+                const dotIndex = lastPart.indexOf('.');
+                fileNameWithoutEnding = dotIndex === -1 ? lastPart : lastPart.slice(0, dotIndex);
+            }
+            const separatorIndex = key.indexOf(CACHE_KEY_SEPARATOR);
+            const filePart = key.slice(separatorIndex + CACHE_KEY_SEPARATOR.length);
+            if (
+                filePart === fileNameWithoutEnding ||
+                filePart.includes(`/${fileNameWithoutEnding}.`)
+            ) {
+                const containingFile = key.slice(0, separatorIndex);
                 this.cache.delete(key);
                 this.pendingInvalidations.add(containingFile);
             }
         });
     }
 
     private getKey(moduleName: string, containingFile: string) {
-        return containingFile + CACHE_KEY_SEPARATOR + ensureRealSvelteFilePath(moduleName);
+        return (
+            path.dirname(containingFile) +
+            CACHE_KEY_SEPARATOR +
+            ensureRealSvelteFilePath(moduleName)
+        );
     }
 
     clearPendingInvalidations() {

packages/language-server/src/utils.ts

@@ -60,7 +60,10 @@ export function normalizeUri(uri: string): string {
  * (bar or bar.svelte in this example).
  */
 export function getLastPartOfPath(path: string): string {
-    return path.replace(/\\/g, '/').split('/').pop() || '';
+    const lastSlash = path.lastIndexOf('/');
+    const lastBackslash = path.lastIndexOf('\\');
+    const lastSeparator = Math.max(lastSlash, lastBackslash);
+    return lastSeparator === -1 ? path : path.slice(lastSeparator + 1);
 }
 
 export function flatten<T>(arr: Array<T | T[]>): T[] {