fix: map refactor/quick-fix of svelte files in typescript plugin (#2439)

#2435

packages/typescript-plugin/src/index.ts

@@ -146,7 +146,8 @@ function init(modules: { typescript: typeof ts }): ts.server.PluginModule {
  // don't clear semantic cache here
  // typescript now expected the program updates to be completely in their control
  // doing so will result in a crash
- info.project.markAsDirty();
+ // @ts-expect-error internal API since TS 5.5
+ info.project.markAsDirty?.();
 
  // updateGraph checks for new root files
  // if there's no tsconfig there isn't root files to check

packages/typescript-plugin/src/language-service/code-action.ts

@@ -0,0 +1,178 @@
+import type ts from 'typescript';
+import { SvelteSnapshot, SvelteSnapshotManager } from '../svelte-snapshots';
+import { isNotNullOrUndefined, isSvelteFilePath } from '../utils';
+
+type _ts = typeof ts;
+
+export function decorateQuickFixAndRefactor(
+ ls: ts.LanguageService,
+ ts: _ts,
+ snapshotManager: SvelteSnapshotManager
+) {
+ const getEditsForRefactor = ls.getEditsForRefactor;
+ const getCodeFixesAtPosition = ls.getCodeFixesAtPosition;
+
+ ls.getEditsForRefactor = (...args) => {
+ const result = getEditsForRefactor(...args);
+
+ if (!result) {
+ return;
+ }
+
+ const edits = result.edits.map(mapFileTextChanges).filter(isNotNullOrUndefined);
+ if (edits.length === 0) {
+ return;
+ }
+
+ return {
+ ...result,
+ edits
+ };
+ };
+
+ ls.getCodeFixesAtPosition = (...args) => {
+ const result = getCodeFixesAtPosition(...args);
+
+ return result
+ .map((fix) => {
+ return {
+ ...fix,
+ changes: fix.changes.map(mapFileTextChanges).filter(isNotNullOrUndefined)
+ };
+ })
+ .filter((fix) => fix.changes.length > 0);
+ };
+
+ function mapFileTextChanges(change: ts.FileTextChanges) {
+ const snapshot = snapshotManager.get(change.fileName);
+ if (!isSvelteFilePath(change.fileName) || !snapshot) {
+ return change;
+ }
+
+ let baseIndent: string | undefined;
+ const getBaseIndent = () => {
+ if (baseIndent !== undefined) {
+ return baseIndent;
+ }
+
+ baseIndent = getIndentOfFirstStatement(ts, ls, change.fileName, snapshot);
+
+ return baseIndent;
+ };
+
+ const textChanges = change.textChanges
+ .map((textChange) => mapEdit(textChange, snapshot, getBaseIndent))
+ .filter(isNotNullOrUndefined);
+
+ // If part of the text changes are invalid, filter out the whole change
+ if (textChanges.length === 0 || textChanges.length !== change.textChanges.length) {
+ return null;
+ }
+
+ return {
+ ...change,
+ textChanges
+ };
+ }
+}
+
+function mapEdit(change: ts.TextChange, snapshot: SvelteSnapshot, getBaseIndent: () => string) {
+ const isNewImportStatement = change.newText.trimStart().startsWith('import');
+ if (isNewImportStatement) {
+ return mapNewImport(change, snapshot, getBaseIndent);
+ }
+
+ const span = snapshot.getOriginalTextSpan(change.span);
+
+ if (!span) {
+ return null;
+ }
+
+ return {
+ span,
+ newText: change.newText
+ };
+}
+
+function mapNewImport(
+ change: ts.TextChange,
+ snapshot: SvelteSnapshot,
+ getBaseIndent: () => string
+): ts.TextChange | null {
+ const previousLineEnds = getPreviousLineEnds(snapshot.getText(), change.span.start);
+
+ if (previousLineEnds === -1) {
+ return null;
+ }
+ const mappable = snapshot.getOriginalTextSpan({
+ start: previousLineEnds,
+ length: 0
+ });
+
+ if (!mappable) {
+ // There might not be any import at all but this is rare enough so ignore for now
+ return null;
+ }
+
+ const originalText = snapshot.getOriginalText();
+ const span = {
+ start: originalText.indexOf('\n', mappable.start) + 1,
+ length: change.span.length
+ };
+
+ const baseIndent = getBaseIndent();
+ let newText = baseIndent
+ ? change.newText
+ .split('\n')
+ .map((line) => (line ? baseIndent + line : line))
+ .join('\n')
+ : change.newText;
+
+ return { span, newText };
+}
+
+function getPreviousLineEnds(text: string, start: number) {
+ const index = text.lastIndexOf('\n', start);
+ if (index === -1) {
+ return index;
+ }
+
+ if (text[index - 1] === '\r') {
+ return index - 1;
+ }
+
+ return index;
+}
+
+function getIndentOfFirstStatement(
+ ts: _ts,
+ ls: ts.LanguageService,
+ fileName: string,
+ snapshot: SvelteSnapshot
+) {
+ const firstExportOrImport = ls
+ .getProgram()
+ ?.getSourceFile(fileName)
+ ?.statements.find((node) => ts.isExportDeclaration(node) || ts.isImportDeclaration(node));
+
+ const originalPosition = firstExportOrImport
+ ? snapshot.getOriginalOffset(firstExportOrImport.getStart())
+ : -1;
+ if (originalPosition === -1) {
+ return '';
+ }
+
+ const source = snapshot.getOriginalText();
+ const start = source.lastIndexOf('\n', originalPosition) + 1;
+ let index = start;
+ while (index < originalPosition) {
+ const char = source[index];
+ if (char.trim()) {
+ break;
+ }
+
+ index++;
+ }
+
+ return source.substring(start, index);
+}

packages/typescript-plugin/src/language-service/index.ts

@@ -17,6 +17,7 @@ import { decorateLanguageServiceHost } from './host';
 import { decorateNavigateToItems } from './navigate-to-items';
 import { decorateFileReferences } from './file-references';
 import { decorateMoveToRefactoringFileSuggestions } from './move-to-file';
+import { decorateQuickFixAndRefactor } from './code-action';
 
 const patchedProject = new Set<string>();
 
@@ -66,6 +67,7 @@ function decorateLanguageServiceInner(
  decorateNavigateToItems(ls, snapshotManager);
  decorateFileReferences(ls, snapshotManager);
  decorateMoveToRefactoringFileSuggestions(ls);
+ decorateQuickFixAndRefactor(ls, typescript, snapshotManager);
  decorateDispose(ls, info.project, onDispose);
  return ls;
 }