@volar/typescript 2.2.0-alpha.1 → 2.2.0-alpha.10

package/lib/node/decorateLanguageService.js

@@ -29,7 +29,7 @@ function decorateLanguageService(language, languageService) {
         }
     };
     // methods
-    const { findReferences, findRenameLocations, getCompletionEntryDetails, getCompletionsAtPosition, getDefinitionAndBoundSpan, getDefinitionAtPosition, getFileReferences, getFormattingEditsForDocument, getFormattingEditsForRange, getFormattingEditsAfterKeystroke, getImplementationAtPosition, getLinkedEditingRangeAtPosition, getQuickInfoAtPosition, getReferencesAtPosition, getSemanticDiagnostics, getSyntacticDiagnostics, getSuggestionDiagnostics, getTypeDefinitionAtPosition, getEncodedSemanticClassifications, getDocumentHighlights, getApplicableRefactors, getEditsForFileRename, getEditsForRefactor, getRenameInfo, getCodeFixesAtPosition, prepareCallHierarchy, provideCallHierarchyIncomingCalls, provideCallHierarchyOutgoingCalls, provideInlayHints, organizeImports, } = languageService;
+    const { findReferences, findRenameLocations, getCompletionEntryDetails, getCompletionsAtPosition, getDefinitionAndBoundSpan, getDefinitionAtPosition, getFileReferences, getFormattingEditsForDocument, getFormattingEditsForRange, getFormattingEditsAfterKeystroke, getImplementationAtPosition, getLinkedEditingRangeAtPosition, getQuickInfoAtPosition, getSignatureHelpItems, getReferencesAtPosition, getSemanticDiagnostics, getSyntacticDiagnostics, getSuggestionDiagnostics, getTypeDefinitionAtPosition, getEncodedSemanticClassifications, getDocumentHighlights, getApplicableRefactors, getEditsForFileRename, getEditsForRefactor, getRenameInfo, getCodeFixesAtPosition, prepareCallHierarchy, provideCallHierarchyIncomingCalls, provideCallHierarchyOutgoingCalls, provideInlayHints, organizeImports, } = languageService;
     languageService.getFormattingEditsForDocument = (fileName, options) => {
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
@@ -200,6 +200,27 @@ function decorateLanguageService(language, languageService) {
             return getQuickInfoAtPosition(fileName, position);
         }
     };
+    languageService.getSignatureHelpItems = (fileName, position, options) => {
+        const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
+        if (serviceScript) {
+            const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isSignatureHelpEnabled);
+            if (generatePosition !== undefined) {
+                const result = getSignatureHelpItems(fileName, generatePosition, options);
+                if (result) {
+                    const applicableSpan = (0, transform_1.transformTextSpan)(sourceScript, map, result.applicableSpan, language_core_1.isSignatureHelpEnabled);
+                    if (applicableSpan) {
+                        return {
+                            ...result,
+                            applicableSpan,
+                        };
+                    }
+                }
+            }
+        }
+        else {
+            return getSignatureHelpItems(fileName, position, options);
+        }
+    };
     languageService.getDocumentHighlights = (fileName, position, filesToSearch) => {
         const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isHighlightEnabled, position => getDocumentHighlights(fileName, position, filesToSearch), function* (result) {
             for (const ref of result) {
@@ -356,17 +377,17 @@ function decorateLanguageService(language, languageService) {
     };
     languageService.getSyntacticDiagnostics = fileName => {
         return getSyntacticDiagnostics(fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, false))
             .filter(utils_1.notEmpty);
     };
     languageService.getSemanticDiagnostics = fileName => {
         return getSemanticDiagnostics(fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, false))
             .filter(utils_1.notEmpty);
     };
     languageService.getSuggestionDiagnostics = fileName => {
         return getSuggestionDiagnostics(fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, false))
             .filter(utils_1.notEmpty);
     };
     languageService.getDefinitionAndBoundSpan = (fileName, position) => {
@@ -403,18 +424,15 @@ function decorateLanguageService(language, languageService) {
         const resolved = unresolved
             .flat()
             .map(symbol => {
-            const definition = (0, transform_1.transformDocumentSpan)(language, symbol.definition, language_core_1.isDefinitionEnabled);
-            if (definition) {
-                return {
-                    definition,
-                    references: symbol.references
-                        .map(r => (0, transform_1.transformDocumentSpan)(language, r, language_core_1.isReferencesEnabled))
-                        .filter(utils_1.notEmpty),
-                };
-            }
-        })
-            .filter(utils_1.notEmpty);
-        return (0, dedupe_1.dedupeReferencedSymbols)(resolved);
+            const definition = (0, transform_1.transformDocumentSpan)(language, symbol.definition, language_core_1.isDefinitionEnabled, true);
+            return {
+                definition,
+                references: symbol.references
+                    .map(r => (0, transform_1.transformDocumentSpan)(language, r, language_core_1.isReferencesEnabled))
+                    .filter(utils_1.notEmpty),
+            };
+        });
+        return resolved;
     };
     languageService.getDefinitionAtPosition = (fileName, position) => {
         const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isDefinitionEnabled, position => getDefinitionAtPosition(fileName, position), function* (result) {
@@ -587,7 +605,7 @@ function decorateLanguageService(language, languageService) {
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
     function linkedCodeFeatureWorker(fileName, position, filter, worker, getLinkedCodes) {
-        let results = [];
+        const results = [];
         const processedFilePositions = new Set();
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
@@ -610,7 +628,7 @@ function decorateLanguageService(language, languageService) {
             if (!result) {
                 return;
             }
-            results = results.concat(result);
+            results.push(result);
             for (const ref of getLinkedCodes(result)) {
                 processedFilePositions.add(ref[0] + ':' + ref[1]);
                 const [virtualFile, sourceScript] = (0, utils_1.getServiceScript)(language, ref[0]);

package/lib/node/decorateLanguageServiceHost.d.ts

@@ -1,4 +1,4 @@
-import { type Language } from '@volar/language-core';
+import type { Language } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function decorateLanguageServiceHost(language: Language, languageServiceHost: ts.LanguageServiceHost, ts: typeof import('typescript')): void;
+export declare function decorateLanguageServiceHost(ts: typeof import('typescript'), language: Language, languageServiceHost: ts.LanguageServiceHost): void;
 export declare function searchExternalFiles(ts: typeof import('typescript'), project: ts.server.Project, exts: string[]): string[];

package/lib/node/decorateLanguageServiceHost.js

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchExternalFiles = exports.decorateLanguageServiceHost = void 0;
-const language_core_1 = require("@volar/language-core");
 const resolveModuleName_1 = require("../resolveModuleName");
-function decorateLanguageServiceHost(language, languageServiceHost, ts) {
-    let extraProjectVersion = 0;
-    const exts = language.plugins
+function decorateLanguageServiceHost(ts, language, languageServiceHost) {
+    const extensions = language.plugins
         .map(plugin => plugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [])
         .flat();
     const scripts = new Map();
+    const crashFileNames = new Set();
     const readDirectory = languageServiceHost.readDirectory?.bind(languageServiceHost);
     const resolveModuleNameLiterals = languageServiceHost.resolveModuleNameLiterals?.bind(languageServiceHost);
     const resolveModuleNames = languageServiceHost.resolveModuleNames?.bind(languageServiceHost);
-    const getProjectVersion = languageServiceHost.getProjectVersion?.bind(languageServiceHost);
     const getScriptSnapshot = languageServiceHost.getScriptSnapshot.bind(languageServiceHost);
     const getScriptKind = languageServiceHost.getScriptKind?.bind(languageServiceHost);
     // path completion
     if (readDirectory) {
         languageServiceHost.readDirectory = (path, extensions, exclude, include, depth) => {
             if (extensions) {
-                for (const ext of exts) {
+                for (const ext of extensions) {
                     if (!extensions.includes(ext)) {
                         extensions = [...extensions, ...ext];
                     }
@@ -28,34 +26,33 @@ function decorateLanguageServiceHost(language, languageServiceHost, ts) {
             return readDirectory(path, extensions, exclude, include, depth);
         };
     }
-    if (language.plugins.some(language => language.typescript?.extraFileExtensions.length)) {
+    if (extensions.length) {
         const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, language.plugins, fileName => language.scripts.get(fileName));
+        const getCanonicalFileName = languageServiceHost.useCaseSensitiveFileNames?.()
+            ? (fileName) => fileName
+            : (fileName) => fileName.toLowerCase();
+        const moduleResolutionCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), getCanonicalFileName, languageServiceHost.getCompilationSettings());
         if (resolveModuleNameLiterals) {
             languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, ...rest) => {
-                if (moduleLiterals.every(name => !exts.some(ext => name.text.endsWith(ext)))) {
+                if (moduleLiterals.every(name => !extensions.some(ext => name.text.endsWith(ext)))) {
                     return resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, ...rest);
                 }
                 return moduleLiterals.map(moduleLiteral => {
-                    return resolveModuleName(moduleLiteral.text, containingFile, options, undefined, redirectedReference);
+                    return resolveModuleName(moduleLiteral.text, containingFile, options, moduleResolutionCache, redirectedReference);
                 });
             };
         }
         if (resolveModuleNames) {
             languageServiceHost.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
-                if (moduleNames.every(name => !exts.some(ext => name.endsWith(ext)))) {
+                if (moduleNames.every(name => !extensions.some(ext => name.endsWith(ext)))) {
                     return resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile);
                 }
                 return moduleNames.map(moduleName => {
-                    return resolveModuleName(moduleName, containingFile, options, undefined, redirectedReference).resolvedModule;
+                    return resolveModuleName(moduleName, containingFile, options, moduleResolutionCache, redirectedReference).resolvedModule;
                 });
             };
         }
     }
-    if (getProjectVersion) {
-        languageServiceHost.getProjectVersion = () => {
-            return getProjectVersion() + ':' + extraProjectVersion;
-        };
-    }
     languageServiceHost.getScriptSnapshot = fileName => {
         const virtualScript = updateVirtualScript(fileName);
         if (virtualScript) {
@@ -73,46 +70,44 @@ function decorateLanguageServiceHost(language, languageServiceHost, ts) {
         };
     }
     function updateVirtualScript(fileName) {
-        const version = languageServiceHost.getScriptVersion(fileName);
-        if (version !== scripts.get(fileName)?.[0]) {
-            let extension = '.ts';
-            let snapshotSnapshot;
-            let scriptKind = ts.ScriptKind.TS;
-            const snapshot = getScriptSnapshot(fileName);
-            if (snapshot) {
-                extraProjectVersion++;
-                const sourceScript = language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
-                if (sourceScript.generated) {
-                    const text = snapshot.getText(0, snapshot.getLength());
-                    let patchedText = text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
-                    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
-                    if (serviceScript) {
-                        extension = serviceScript.extension;
-                        scriptKind = serviceScript.scriptKind;
-                        patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
-                    }
-                    snapshotSnapshot = ts.ScriptSnapshot.fromString(patchedText);
-                    if (sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts) {
-                        console.warn('getExtraScripts() is not available in this use case.');
-                    }
+        if (crashFileNames.has(fileName)) {
+            return;
+        }
+        let version;
+        try {
+            version = languageServiceHost.getScriptVersion(fileName);
+        }
+        catch {
+            // fix https://github.com/vuejs/language-tools/issues/4278
+            crashFileNames.add(fileName);
+        }
+        if (version === undefined) {
+            // somehow getScriptVersion returns undefined
+            return;
+        }
+        let script = scripts.get(fileName);
+        if (!script || script[0] !== version) {
+            script = [version];
+            const sourceScript = language.scripts.get(fileName);
+            if (sourceScript?.generated) {
+                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                if (serviceScript) {
+                    const sourceContents = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength());
+                    let virtualContents = sourceContents.split('\n').map(line => ' '.repeat(line.length)).join('\n');
+                    virtualContents += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
+                    script[1] = {
+                        extension: serviceScript.extension,
+                        kind: serviceScript.scriptKind,
+                        snapshot: ts.ScriptSnapshot.fromString(virtualContents),
+                    };
+                }
+                if (sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts) {
+                    console.warn('getExtraServiceScripts() is not available in TS plugin.');
                 }
             }
-            else if (language.scripts.get(fileName)) {
-                extraProjectVersion++;
-                language.scripts.delete(fileName);
-            }
-            if (snapshotSnapshot) {
-                scripts.set(fileName, [
-                    version,
-                    {
-                        extension,
-                        snapshot: snapshotSnapshot,
-                        kind: scriptKind,
-                    }
-                ]);
-            }
+            scripts.set(fileName, script);
         }
-        return scripts.get(fileName)?.[1];
+        return script[1];
     }
 }
 exports.decorateLanguageServiceHost = decorateLanguageServiceHost;

package/lib/node/decorateProgram.js

@@ -9,6 +9,7 @@ function decorateProgram(language, program) {
     const getSyntacticDiagnostics = program.getSyntacticDiagnostics;
     const getSemanticDiagnostics = program.getSemanticDiagnostics;
     const getGlobalDiagnostics = program.getGlobalDiagnostics;
+    const getSourceFileByPath = program.getSourceFileByPath;
     // for tsc --noEmit --watch
     // @ts-ignore
     const getBindAndCheckDiagnostics = program.getBindAndCheckDiagnostics;
@@ -17,31 +18,39 @@ function decorateProgram(language, program) {
         return {
             ...result,
             diagnostics: result.diagnostics
-                .map(d => (0, transform_1.transformDiagnostic)(language, d))
+                .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
                 .filter(utils_1.notEmpty),
         };
     };
     program.getSyntacticDiagnostics = (sourceFile, cancellationToken) => {
         return getSyntacticDiagnostics(sourceFile, cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
     program.getSemanticDiagnostics = (sourceFile, cancellationToken) => {
         return getSemanticDiagnostics(sourceFile, cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
     program.getGlobalDiagnostics = cancellationToken => {
         return getGlobalDiagnostics(cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
     // @ts-ignore
     program.getBindAndCheckDiagnostics = (sourceFile, cancellationToken) => {
         return getBindAndCheckDiagnostics(sourceFile, cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
+    // fix https://github.com/vuejs/language-tools/issues/4099 with `incremental`
+    program.getSourceFileByPath = path => {
+        const sourceFile = getSourceFileByPath(path);
+        if (sourceFile) {
+            (0, transform_1.fillSourceFileText)(language, sourceFile);
+        }
+        return sourceFile;
+    };
 }
 exports.decorateProgram = decorateProgram;
 //# sourceMappingURL=decorateProgram.js.map

package/lib/node/dedupe.d.ts

@@ -1,3 +1,2 @@
 import type * as ts from 'typescript';
-export declare function dedupeReferencedSymbols<T extends ts.ReferencedSymbol>(items: T[]): T[];
 export declare function dedupeDocumentSpans<T extends ts.DocumentSpan>(items: T[]): T[];

package/lib/node/dedupe.js

@@ -1,14 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dedupeDocumentSpans = exports.dedupeReferencedSymbols = void 0;
-function dedupeReferencedSymbols(items) {
-    return dedupe(items, item => [
-        item.definition.fileName,
-        item.definition.textSpan.start,
-        item.definition.textSpan.length,
-    ].join(':'));
-}
-exports.dedupeReferencedSymbols = dedupeReferencedSymbols;
+exports.dedupeDocumentSpans = void 0;
 function dedupeDocumentSpans(items) {
     return dedupe(items, item => [
         item.fileName,

package/lib/node/proxyCreateProgram.d.ts

@@ -1,3 +1,3 @@
-import type * as ts from 'typescript';
 import { LanguagePlugin } from '@volar/language-core';
-export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], extensions: string[], getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[]): typeof import("typescript").createProgram;
+import type * as ts from 'typescript';
+export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[], getLanguageId: (fileName: string) => string): typeof import("typescript").createProgram;

package/lib/node/proxyCreateProgram.js

@@ -1,117 +1,161 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.proxyCreateProgram = void 0;
-const decorateProgram_1 = require("./decorateProgram");
 const language_core_1 = require("@volar/language-core");
-function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
+const resolveModuleName_1 = require("../resolveModuleName");
+const decorateProgram_1 = require("./decorateProgram");
+const arrayEqual = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+};
+const objectEqual = (a, b) => {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (const key of keysA) {
+        if (a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+};
+function proxyCreateProgram(ts, original, getLanguagePlugins, getLanguageId) {
+    const sourceFileSnapshots = new Map();
+    const parsedSourceFiles = new WeakMap();
+    let lastOptions;
+    let languagePlugins;
+    let language;
+    let moduleResolutionCache;
     return new Proxy(original, {
         apply: (target, thisArg, args) => {
             const options = args[0];
             assert(!!options.host, '!!options.host');
-            const sourceFileToSnapshotMap = new WeakMap();
-            const language = (0, language_core_1.createLanguage)(getLanguagePlugins(ts, options), ts.sys.useCaseSensitiveFileNames, fileName => {
-                let snapshot;
-                assert(originalSourceFiles.has(fileName), `originalSourceFiles.has(${fileName})`);
-                const sourceFile = originalSourceFiles.get(fileName);
-                if (sourceFile) {
-                    snapshot = sourceFileToSnapshotMap.get(sourceFile);
-                    if (!snapshot) {
-                        snapshot = {
-                            getChangeRange() {
-                                return undefined;
-                            },
-                            getLength() {
-                                return sourceFile.text.length;
-                            },
-                            getText(start, end) {
-                                return sourceFile.text.substring(start, end);
-                            },
-                        };
-                        sourceFileToSnapshotMap.set(sourceFile, snapshot);
-                    }
-                }
-                if (snapshot) {
-                    language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
-                }
-                else {
-                    language.scripts.delete(fileName);
-                }
-            });
-            const originalSourceFiles = new Map();
-            const parsedSourceFiles = new WeakMap();
-            const arbitraryExtensions = extensions.map(ext => `.d${ext}.ts`);
-            const originalHost = options.host;
-            const moduleResolutionHost = {
-                ...originalHost,
-                fileExists(fileName) {
-                    for (let i = 0; i < arbitraryExtensions.length; i++) {
-                        if (fileName.endsWith(arbitraryExtensions[i])) {
-                            return originalHost.fileExists(fileName.slice(0, -arbitraryExtensions[i].length) + extensions[i]);
+            if (!lastOptions
+                || !languagePlugins
+                || !language
+                || !arrayEqual(options.rootNames, lastOptions.rootNames)
+                || !objectEqual(options.options, lastOptions.options)) {
+                moduleResolutionCache = ts.createModuleResolutionCache(options.host.getCurrentDirectory(), options.host.getCanonicalFileName, options.options);
+                lastOptions = options;
+                languagePlugins = getLanguagePlugins(ts, options);
+                language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                    if (!sourceFileSnapshots.has(fileName)) {
+                        const sourceFileText = originalHost.readFile(fileName);
+                        if (sourceFileText !== undefined) {
+                            sourceFileSnapshots.set(fileName, [undefined, {
+                                    getChangeRange() {
+                                        return undefined;
+                                    },
+                                    getLength() {
+                                        return sourceFileText.length;
+                                    },
+                                    getText(start, end) {
+                                        return sourceFileText.substring(start, end);
+                                    },
+                                }]);
+                        }
+                        else {
+                            sourceFileSnapshots.set(fileName, [undefined, undefined]);
                         }
                     }
-                    return originalHost.fileExists(fileName);
-                },
-            };
+                    const snapshot = sourceFileSnapshots.get(fileName)?.[1];
+                    if (snapshot) {
+                        language.scripts.set(fileName, getLanguageId(fileName), snapshot);
+                    }
+                    else {
+                        language.scripts.delete(fileName);
+                    }
+                });
+            }
+            const originalHost = options.host;
+            const extensions = languagePlugins
+                .map(plugin => plugin.typescript?.extraFileExtensions.map(({ extension }) => `.${extension}`) ?? [])
+                .flat();
             options.host = { ...originalHost };
-            options.options.allowArbitraryExtensions = true;
             options.host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
                 const originalSourceFile = originalHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
-                originalSourceFiles.set(fileName, originalSourceFile);
-                if (originalSourceFile && extensions.some(ext => fileName.endsWith(ext))) {
-                    let sourceFile2 = parsedSourceFiles.get(originalSourceFile);
-                    if (!sourceFile2) {
-                        const sourceScript = language.scripts.get(fileName);
-                        assert(!!sourceScript, '!!sourceScript');
-                        let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
-                        let scriptKind = ts.ScriptKind.TS;
-                        if (sourceScript.generated?.languagePlugin.typescript) {
-                            const { getServiceScript: getScript, getExtraServiceScripts: getExtraScripts } = sourceScript.generated.languagePlugin.typescript;
-                            const serviceScript = getScript(sourceScript.generated.root);
-                            if (serviceScript) {
-                                scriptKind = serviceScript.scriptKind;
-                                patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
-                            }
-                            if (getExtraScripts) {
-                                console.warn('getExtraScripts() is not available in this use case.');
-                            }
+                if (!sourceFileSnapshots.has(fileName)
+                    || sourceFileSnapshots.get(fileName)?.[0] !== originalSourceFile) {
+                    if (originalSourceFile) {
+                        sourceFileSnapshots.set(fileName, [originalSourceFile, {
+                                getChangeRange() {
+                                    return undefined;
+                                },
+                                getLength() {
+                                    return originalSourceFile.text.length;
+                                },
+                                getText(start, end) {
+                                    return originalSourceFile.text.substring(start, end);
+                                },
+                            }]);
+                    }
+                    else {
+                        sourceFileSnapshots.set(fileName, [undefined, undefined]);
+                    }
+                }
+                if (!originalSourceFile) {
+                    return;
+                }
+                if (!parsedSourceFiles.has(originalSourceFile)) {
+                    const sourceScript = language.scripts.get(fileName);
+                    assert(!!sourceScript, '!!sourceScript');
+                    parsedSourceFiles.set(originalSourceFile, originalSourceFile);
+                    if (sourceScript.generated?.languagePlugin.typescript) {
+                        const { getServiceScript, getExtraServiceScripts } = sourceScript.generated.languagePlugin.typescript;
+                        const serviceScript = getServiceScript(sourceScript.generated.root);
+                        if (serviceScript) {
+                            let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
+                            let scriptKind = ts.ScriptKind.TS;
+                            scriptKind = serviceScript.scriptKind;
+                            patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
+                            const parsedSourceFile = ts.createSourceFile(fileName, patchedText, languageVersionOrOptions, undefined, scriptKind);
+                            // @ts-expect-error
+                            parsedSourceFile.version = originalSourceFile.version;
+                            parsedSourceFiles.set(originalSourceFile, parsedSourceFile);
+                        }
+                        if (getExtraServiceScripts) {
+                            console.warn('getExtraServiceScripts() is not available in this use case.');
                         }
-                        sourceFile2 = ts.createSourceFile(fileName, patchedText, 99, true, scriptKind);
-                        // @ts-expect-error
-                        sourceFile2.version = originalSourceFile.version;
-                        parsedSourceFiles.set(originalSourceFile, sourceFile2);
                     }
-                    return sourceFile2;
                 }
-                return originalSourceFile;
-            };
-            options.host.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options) => {
-                return moduleNames.map(name => {
-                    return resolveModuleName(name.text, containingFile, options, redirectedReference);
-                });
+                return parsedSourceFiles.get(originalSourceFile);
             };
-            options.host.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
-                return moduleNames.map(name => {
-                    return resolveModuleName(name, containingFile, options, redirectedReference).resolvedModule;
-                });
-            };
-            const program = Reflect.apply(target, thisArg, [options]);
+            if (extensions.length) {
+                options.options.allowArbitraryExtensions = true;
+                const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, originalHost, language.plugins, fileName => language.scripts.get(fileName));
+                const resolveModuleNameLiterals = originalHost.resolveModuleNameLiterals;
+                const resolveModuleNames = originalHost.resolveModuleNames;
+                options.host.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest) => {
+                    if (resolveModuleNameLiterals && moduleLiterals.every(name => !extensions.some(ext => name.text.endsWith(ext)))) {
+                        return resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest);
+                    }
+                    return moduleLiterals.map(moduleLiteral => {
+                        return resolveModuleName(moduleLiteral.text, containingFile, compilerOptions, moduleResolutionCache, redirectedReference);
+                    });
+                };
+                options.host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile) => {
+                    if (resolveModuleNames && moduleNames.every(name => !extensions.some(ext => name.endsWith(ext)))) {
+                        return resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile);
+                    }
+                    return moduleNames.map(moduleName => {
+                        return resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionCache, redirectedReference).resolvedModule;
+                    });
+                };
+            }
+            const program = Reflect.apply(target, thisArg, args);
             (0, decorateProgram_1.decorateProgram)(language, program);
             // TODO: #128
-            program.__volar__ = { files: language };
+            program.__volar__ = { language };
             return program;
-            function resolveModuleName(name, containingFile, options, redirectedReference) {
-                const resolved = ts.resolveModuleName(name, containingFile, options, moduleResolutionHost, originalHost.getModuleResolutionCache?.(), redirectedReference);
-                if (resolved.resolvedModule) {
-                    for (let i = 0; i < arbitraryExtensions.length; i++) {
-                        if (resolved.resolvedModule.resolvedFileName.endsWith(arbitraryExtensions[i])) {
-                            const sourceFileName = resolved.resolvedModule.resolvedFileName.slice(0, -arbitraryExtensions[i].length) + extensions[i];
-                            resolved.resolvedModule.resolvedFileName = sourceFileName;
-                            resolved.resolvedModule.extension = extensions[i];
-                        }
-                    }
-                }
-                return resolved;
-            }
         },
     });
 }

package/lib/node/transform.d.ts

@@ -1,7 +1,8 @@
 import { Language, CodeInformation, SourceMap, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
 export declare function transformCallHierarchyItem(language: Language, item: ts.CallHierarchyItem, filter: (data: CodeInformation) => boolean): ts.CallHierarchyItem;
-export declare function transformDiagnostic<T extends ts.Diagnostic>(language: Language, diagnostic: T): T | undefined;
+export declare function transformDiagnostic<T extends ts.Diagnostic>(language: Language, diagnostic: T, isTsc: boolean): T | undefined;
+export declare function fillSourceFileText(language: Language, sourceFile: ts.SourceFile): void;
 export declare function transformFileTextChanges(language: Language, changes: ts.FileTextChanges, filter: (data: CodeInformation) => boolean): ts.FileTextChanges | undefined;
 export declare function transformDocumentSpan<T extends ts.DocumentSpan>(language: Language, documentSpan: T, filter: (data: CodeInformation) => boolean, shouldFallback?: boolean): T | undefined;
 export declare function transformSpan(language: Language, fileName: string | undefined, textSpan: ts.TextSpan | undefined, filter: (data: CodeInformation) => boolean): {

package/lib/node/transform.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toGeneratedOffset = exports.toSourceOffset = exports.transformTextSpan = exports.transformTextChange = exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
+exports.toGeneratedOffset = exports.toSourceOffset = exports.transformTextSpan = exports.transformTextChange = exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.fillSourceFileText = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
 const language_core_1 = require("@volar/language-core");
 const utils_1 = require("./utils");
 const transformedDiagnostics = new WeakMap();
+const transformedSourceFile = new WeakSet();
 function transformCallHierarchyItem(language, item, filter) {
     const span = transformSpan(language, item.file, item.span, filter);
     const selectionSpan = transformSpan(language, item.file, item.selectionSpan, filter);
@@ -14,13 +15,13 @@ function transformCallHierarchyItem(language, item, filter) {
     };
 }
 exports.transformCallHierarchyItem = transformCallHierarchyItem;
-function transformDiagnostic(language, diagnostic) {
+function transformDiagnostic(language, diagnostic, isTsc) {
     if (!transformedDiagnostics.has(diagnostic)) {
         transformedDiagnostics.set(diagnostic, undefined);
         const { relatedInformation } = diagnostic;
         if (relatedInformation) {
             diagnostic.relatedInformation = relatedInformation
-                .map(d => transformDiagnostic(language, d))
+                .map(d => transformDiagnostic(language, d, isTsc))
                 .filter(utils_1.notEmpty);
         }
         if (diagnostic.file !== undefined
@@ -30,6 +31,9 @@ function transformDiagnostic(language, diagnostic) {
             if (serviceScript) {
                 const sourceSpan = transformTextSpan(sourceScript, map, { start: diagnostic.start, length: diagnostic.length }, language_core_1.shouldReportDiagnostics);
                 if (sourceSpan) {
+                    if (isTsc) {
+                        fillSourceFileText(language, diagnostic.file);
+                    }
                     transformedDiagnostics.set(diagnostic, {
                         ...diagnostic,
                         start: sourceSpan.start,
@@ -48,6 +52,19 @@ function transformDiagnostic(language, diagnostic) {
     return transformedDiagnostics.get(diagnostic);
 }
 exports.transformDiagnostic = transformDiagnostic;
+// fix https://github.com/vuejs/language-tools/issues/4099 without `incremental`
+function fillSourceFileText(language, sourceFile) {
+    if (transformedSourceFile.has(sourceFile)) {
+        return;
+    }
+    transformedSourceFile.add(sourceFile);
+    const [serviceScript, sourceScript] = (0, utils_1.getServiceScript)(language, sourceFile.fileName);
+    if (serviceScript) {
+        sourceFile.text = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength())
+            + sourceFile.text.substring(sourceScript.snapshot.getLength());
+    }
+}
+exports.fillSourceFileText = fillSourceFileText;
 function transformFileTextChanges(language, changes, filter) {
     const [_, source] = (0, utils_1.getServiceScript)(language, changes.fileName);
     if (source) {
@@ -72,13 +89,10 @@ exports.transformFileTextChanges = transformFileTextChanges;
 function transformDocumentSpan(language, documentSpan, filter, shouldFallback) {
     let textSpan = transformSpan(language, documentSpan.fileName, documentSpan.textSpan, filter);
     if (!textSpan && shouldFallback) {
-        const [serviceScript] = (0, utils_1.getServiceScript)(language, documentSpan.fileName);
-        if (serviceScript) {
-            textSpan = {
-                fileName: documentSpan.fileName,
-                textSpan: { start: 0, length: 0 },
-            };
-        }
+        textSpan = {
+            fileName: documentSpan.fileName,
+            textSpan: { start: 0, length: 0 },
+        };
     }
     if (!textSpan) {
         return;

package/lib/protocol/createProject.js

@@ -43,7 +43,7 @@ function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
     }
     if (languagePlugins.some(language => language.typescript?.extraFileExtensions.length)) {
         // TODO: can this share between monorepo packages?
-        const moduleCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), languageServiceHost.useCaseSensitiveFileNames ? s => s : s => s.toLowerCase(), languageServiceHost.getCompilationSettings());
+        const moduleCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), languageServiceHost.useCaseSensitiveFileNames?.() ? s => s : s => s.toLowerCase(), languageServiceHost.getCompilationSettings());
         const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, languagePlugins, fileName => language.scripts.get(projectHost.fileNameToScriptId(fileName)));
         let lastSysVersion = projectHost.getSystemVersion?.();
         languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, sourceFile) => {

package/lib/quickstart/createAsyncLanguageServicePlugin.d.ts

@@ -1,3 +1,3 @@
 import type * as ts from 'typescript';
 import { LanguagePlugin } from '@volar/language-core';
-export declare function createAsyncLanguageServicePlugin(extensions: string[], scriptKind: ts.ScriptKind, loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<LanguagePlugin[]>): ts.server.PluginModuleFactory;
+export declare function createAsyncLanguageServicePlugin(extensions: string[], scriptKind: ts.ScriptKind, loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<LanguagePlugin[]>, getLanguageId: (fileName: string) => string): ts.server.PluginModuleFactory;

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -8,7 +8,7 @@ const createLanguageServicePlugin_1 = require("./createLanguageServicePlugin");
 const externalFiles = new WeakMap();
 const decoratedLanguageServices = new WeakSet();
 const decoratedLanguageServiceHosts = new WeakSet();
-function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePlugins) {
+function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePlugins, getLanguageId) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
@@ -55,14 +55,14 @@ function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePl
                         const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
                             const snapshot = getScriptSnapshot(fileName);
                             if (snapshot) {
-                                language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                                language.scripts.set(fileName, getLanguageId(fileName), snapshot);
                             }
                             else {
                                 language.scripts.delete(fileName);
                             }
                         });
                         (0, decorateLanguageService_1.decorateLanguageService)(language, info.languageService);
-                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(language, info.languageServiceHost, ts);
+                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
                         info.project.markAsDirty();
                         initialized = true;
                     });

package/lib/quickstart/createLanguageServicePlugin.d.ts

@@ -1,4 +1,4 @@
 import type * as ts from 'typescript';
 import { LanguagePlugin } from '@volar/language-core';
-export declare function createLanguageServicePlugin(loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => LanguagePlugin[]): ts.server.PluginModuleFactory;
+export declare function createLanguageServicePlugin(loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => LanguagePlugin[], getLanguageId: (fileName: string) => string): ts.server.PluginModuleFactory;
 export declare function arrayItemsEqual(a: string[], b: string[]): boolean;

package/lib/quickstart/createLanguageServicePlugin.js

@@ -8,7 +8,7 @@ const externalFiles = new WeakMap();
 const projectExternalFileExtensions = new WeakMap();
 const decoratedLanguageServices = new WeakSet();
 const decoratedLanguageServiceHosts = new WeakSet();
-function createLanguageServicePlugin(loadLanguagePlugins) {
+function createLanguageServicePlugin(loadLanguagePlugins, getLanguageId) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
@@ -26,14 +26,14 @@ function createLanguageServicePlugin(loadLanguagePlugins) {
                     const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
                         const snapshot = getScriptSnapshot(fileName);
                         if (snapshot) {
-                            language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                            language.scripts.set(fileName, getLanguageId(fileName), snapshot);
                         }
                         else {
                             language.scripts.delete(fileName);
                         }
                     });
                     (0, decorateLanguageService_1.decorateLanguageService)(language, info.languageService);
-                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(language, info.languageServiceHost, ts);
+                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
                 }
                 return info.languageService;
             },

package/lib/quickstart/runTsc.d.ts

@@ -1,4 +1,5 @@
 import type * as ts from 'typescript';
 import type { LanguagePlugin } from '@volar/language-core';
 export declare let getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[];
-export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins): void;
+export declare let getLanguageId: (fileName: string) => string;
+export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins, _getLanguageId: typeof getLanguageId): void;

package/lib/quickstart/runTsc.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTsc = exports.getLanguagePlugins = void 0;
+exports.runTsc = exports.getLanguageId = exports.getLanguagePlugins = void 0;
 const fs = require("fs");
 let getLanguagePlugins = () => [];
 exports.getLanguagePlugins = getLanguagePlugins;
-function runTsc(tscPath, extensions, _getLanguagePlugins) {
+let getLanguageId = () => 'ts';
+exports.getLanguageId = getLanguageId;
+function runTsc(tscPath, extensions, _getLanguagePlugins, _getLanguageId) {
     exports.getLanguagePlugins = _getLanguagePlugins;
+    exports.getLanguageId = _getLanguageId;
     const proxyApiPath = require.resolve('../node/proxyCreateProgram');
     const readFileSync = fs.readFileSync;
     fs.readFileSync = (...args) => {
@@ -18,10 +21,12 @@ function runTsc(tscPath, extensions, _getLanguagePlugins) {
             tsc = replace(tsc, /allSupportedExtensions = .*(?=;)/, s => s + `.concat([[${extsText}]])`);
             // proxy createProgram
             tsc = replace(tsc, /function createProgram\(.+\) {/, s => `var createProgram = require(${JSON.stringify(proxyApiPath)}).proxyCreateProgram(`
-                + `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } ), `
-                + `_createProgram, `
-                + `[${extsText}], `
-                + `require(${JSON.stringify(__filename)}).getLanguagePlugins`
+                + [
+                    `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } )`,
+                    `_createProgram`,
+                    `require(${JSON.stringify(__filename)}).getLanguagePlugins`,
+                    `require(${JSON.stringify(__filename)}).getLanguageId`,
+                ].join(', ')
                 + `);\n`
                 + s.replace('createProgram', '_createProgram'));
             return tsc;

package/lib/resolveModuleName.d.ts

@@ -1,3 +1,3 @@
 import type { LanguagePlugin, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function createResolveModuleName(ts: typeof import('typescript'), languageServiceHost: ts.LanguageServiceHost, languagePlugins: LanguagePlugin<any>[], getSourceScript: (fileName: string) => SourceScript | undefined): (moduleName: string, containingFile: string, compilerOptions: ts.CompilerOptions, cache?: ts.ModuleResolutionCache, redirectedReference?: ts.ResolvedProjectReference, resolutionMode?: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations;
+export declare function createResolveModuleName(ts: typeof import('typescript'), host: ts.ModuleResolutionHost, languagePlugins: LanguagePlugin<any>[], getSourceScript: (fileName: string) => SourceScript | undefined): (moduleName: string, containingFile: string, compilerOptions: ts.CompilerOptions, cache?: ts.ModuleResolutionCache, redirectedReference?: ts.ResolvedProjectReference, resolutionMode?: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations;

package/lib/resolveModuleName.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createResolveModuleName = void 0;
-function createResolveModuleName(ts, languageServiceHost, languagePlugins, getSourceScript) {
-    const toPatchResults = new Map();
+function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
+    const toSourceFileInfo = new Map();
     const moduleResolutionHost = {
-        readFile: languageServiceHost.readFile.bind(languageServiceHost),
-        directoryExists: languageServiceHost.directoryExists?.bind(languageServiceHost),
-        realpath: languageServiceHost.realpath?.bind(languageServiceHost),
-        getCurrentDirectory: languageServiceHost.getCurrentDirectory.bind(languageServiceHost),
-        getDirectories: languageServiceHost.getDirectories?.bind(languageServiceHost),
-        useCaseSensitiveFileNames: languageServiceHost.useCaseSensitiveFileNames?.bind(languageServiceHost),
+        readFile: host.readFile.bind(host),
+        directoryExists: host.directoryExists?.bind(host),
+        realpath: host.realpath?.bind(host),
+        getCurrentDirectory: host.getCurrentDirectory?.bind(host),
+        getDirectories: host.getDirectories?.bind(host),
+        useCaseSensitiveFileNames: typeof host.useCaseSensitiveFileNames === 'function'
+            ? host.useCaseSensitiveFileNames.bind(host)
+            : host.useCaseSensitiveFileNames,
         fileExists(fileName) {
             for (const { typescript } of languagePlugins) {
                 if (!typescript) {
@@ -17,36 +19,51 @@ function createResolveModuleName(ts, languageServiceHost, languagePlugins, getSo
                 }
                 for (const { extension } of typescript.extraFileExtensions) {
                     if (fileName.endsWith(`.d.${extension}.ts`)) {
-                        const patchFileName = fileName.slice(0, -`.d.${extension}.ts`.length) + `.${extension}`;
-                        if (fileExists(patchFileName)) {
-                            toPatchResults.set(fileName, patchFileName);
-                            return true;
+                        const sourceFileName = fileName.slice(0, -`.d.${extension}.ts`.length) + `.${extension}`;
+                        if (fileExists(sourceFileName)) {
+                            const sourceScript = getSourceScript(sourceFileName);
+                            if (sourceScript?.generated) {
+                                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                                if (serviceScript) {
+                                    const dtsPath = sourceFileName + '.d.ts';
+                                    if ((serviceScript.extension === '.js' || serviceScript.extension === '.jsx') && fileExists(dtsPath)) {
+                                        toSourceFileInfo.set(fileName, {
+                                            sourceFileName: dtsPath,
+                                            extension: '.ts',
+                                        });
+                                    }
+                                    else {
+                                        toSourceFileInfo.set(fileName, {
+                                            sourceFileName,
+                                            extension: serviceScript.extension,
+                                        });
+                                    }
+                                    return true;
+                                }
+                            }
                         }
                     }
                 }
             }
-            return languageServiceHost.fileExists(fileName);
+            return host.fileExists(fileName);
         },
     };
     return (moduleName, containingFile, compilerOptions, cache, redirectedReference, resolutionMode) => {
         const result = ts.resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost, cache, redirectedReference, resolutionMode);
-        if (result.resolvedModule && toPatchResults.has(result.resolvedModule.resolvedFileName)) {
-            result.resolvedModule.resolvedFileName = toPatchResults.get(result.resolvedModule.resolvedFileName);
-            const sourceScript = getSourceScript(result.resolvedModule.resolvedFileName);
-            if (sourceScript?.generated) {
-                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
-                if (serviceScript) {
-                    result.resolvedModule.extension = serviceScript.extension;
-                }
+        if (result.resolvedModule) {
+            const sourceFileInfo = toSourceFileInfo.get(result.resolvedModule.resolvedFileName);
+            if (sourceFileInfo) {
+                result.resolvedModule.resolvedFileName = sourceFileInfo.sourceFileName;
+                result.resolvedModule.extension = sourceFileInfo.extension;
             }
         }
-        toPatchResults.clear();
+        toSourceFileInfo.clear();
         return result;
     };
     // fix https://github.com/vuejs/language-tools/issues/3332
     function fileExists(fileName) {
-        if (languageServiceHost.fileExists(fileName)) {
-            const fileSize = ts.sys.getFileSize?.(fileName) ?? languageServiceHost.readFile(fileName)?.length ?? 0;
+        if (host.fileExists(fileName)) {
+            const fileSize = ts.sys.getFileSize?.(fileName) ?? host.readFile(fileName)?.length ?? 0;
             return fileSize < 4 * 1024 * 1024;
         }
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "2.2.0-alpha.1",
+	"version": "2.2.0-alpha.10",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,13 +12,13 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.2.0-alpha.1",
+		"@volar/language-core": "2.2.0-alpha.10",
 		"path-browserify": "^1.0.1"
 	},
 	"devDependencies": {
 		"@types/node": "latest",
 		"@types/path-browserify": "latest",
-		"@volar/language-service": "2.2.0-alpha.1"
+		"@volar/language-service": "2.2.0-alpha.10"
 	},
-	"gitHead": "e6dcb83ecadcfcc9e22083eea61e1ee817a9d483"
+	"gitHead": "aedd2230883c457f703be93ed150917a3efde75c"
 }