Feature: Code fixes

.vscode/launch.json

@@ -123,7 +123,7 @@
         "TYPESPEC_DEVELOPMENT_MODE": "true"
       },
       "presentation": {
-        "hidden": true
+        "hidden": true  
       }
     },
     {

packages/compiler/src/core/code-fixes.ts

@@ -0,0 +1,41 @@
+import type {
+  CodeFix,
+  CodeFixContext,
+  CodeFixEdit,
+  PrependTextCodeFixEdit,
+  ReplaceTextCodeFixEdit,
+  SourceLocation,
+} from "./types.js";
+import { isArray } from "./util.js";
+
+export async function resolveCodeFix(codeFix: CodeFix): Promise<CodeFixEdit[]> {
+  const context = createCodeFixContext();
+  const values = await codeFix.fix(context);
+  const textEdit = values === undefined ? [] : isArray(values) ? values : [values];
+  return textEdit;
+}
+
+function createCodeFixContext(): CodeFixContext {
+  return {
+    prependText,
+    replaceText,
+  };
+
+  function prependText(node: SourceLocation, text: string): PrependTextCodeFixEdit {
+    return {
+      kind: "prepend-text",
+      pos: node.pos,
+      text,
+      file: node.file,
+    };
+  }
+  function replaceText(node: SourceLocation, text: string): ReplaceTextCodeFixEdit {
+    return {
+      kind: "replace-text",
+      pos: node.pos,
+      end: node.end,
+      file: node.file,
+      text,
+    };
+  }
+}

packages/compiler/src/core/compiler-code-fixes/suppress.codefix.ts

@@ -0,0 +1,31 @@
+import { isWhiteSpace } from "../charcode.js";
+import { defineCodeFix, getSourceLocation } from "../diagnostics.js";
+import type { DiagnosticTarget, SourceLocation } from "../types.js";
+
+export function createSuppressCodeFix(diagnosticTarget: DiagnosticTarget, warningCode: string) {
+  return defineCodeFix({
+    id: "suppress",
+    label: `Suppress warning: "${warningCode}"`,
+    fix: (context) => {
+      const location = getSourceLocation(diagnosticTarget);
+      const { lineStart, indent } = findLineStartAndIndent(location);
+      const updatedLocation = { ...location, pos: lineStart };
+      return context.prependText(updatedLocation, `${indent}#suppress "${warningCode}" ""\n`);
+    },
+  });
+}
+
+function findLineStartAndIndent(location: SourceLocation): { lineStart: number; indent: string } {
+  const text = location.file.text;
+  let pos = location.pos;
+  let indent = 0;
+  while (pos > 0 && text[pos - 1] !== "\n") {
+    if (isWhiteSpace(text.charCodeAt(pos - 1))) {
+      indent++;
+    } else {
+      indent = 0;
+    }
+    pos--;
+  }
+  return { lineStart: pos, indent: location.file.text.slice(pos, pos + indent) };
+}

packages/compiler/src/core/diagnostics.ts

@@ -2,6 +2,7 @@ import { CharCode } from "./charcode.js";
 import { formatLog } from "./logger/index.js";
 import type { Program } from "./program.js";
 import {
+  CodeFix,
   Diagnostic,
   DiagnosticResult,
   DiagnosticTarget,
@@ -386,3 +387,7 @@ export function createDiagnosticCollector(): DiagnosticCollector {
 export function ignoreDiagnostics<T>(result: DiagnosticResult<T>): T {
   return result[0];
 }
+
+export function defineCodeFix(fix: CodeFix): CodeFix {
+  return fix;
+}

packages/compiler/src/core/program.ts

@@ -4,6 +4,7 @@ import { validateEncodedNamesConflicts } from "../lib/encoded-names.js";
 import { MANIFEST } from "../manifest.js";
 import { createBinder } from "./binder.js";
 import { Checker, createChecker } from "./checker.js";
+import { createSuppressCodeFix } from "./compiler-code-fixes/suppress.codefix.js";
 import { compilerAssert, createSourceFile } from "./diagnostics.js";
 import {
   resolveTypeSpecEntrypoint,
@@ -1047,6 +1048,11 @@ export async function compile(
       return;
     }
 
+    if (diagnostic.severity === "warning" && diagnostic.target !== NoTarget) {
+      mutate(diagnostic).codefixes ??= [];
+      mutate(diagnostic.codefixes).push(createSuppressCodeFix(diagnostic.target, diagnostic.code));
+    }
+
     if (options.warningAsError && diagnostic.severity === "warning") {
       diagnostic = { ...diagnostic, severity: "error" };
     }

packages/compiler/src/core/types.ts

@@ -1849,6 +1849,33 @@ export interface Diagnostic {
   severity: DiagnosticSeverity;
   message: string;
   target: DiagnosticTarget | typeof NoTarget;
+  readonly codefixes?: readonly CodeFix[];
+}
+
+export interface CodeFix {
+  readonly id: string;
+  readonly label: string;
+  readonly fix: (fixContext: CodeFixContext) => CodeFixEdit | CodeFixEdit[] | Promise<void> | void;
+}
+
+export interface CodeFixContext {
+  readonly prependText: (location: SourceLocation, text: string) => PrependTextCodeFixEdit;
+  readonly replaceText: (location: SourceLocation, newText: string) => ReplaceTextCodeFixEdit;
+}
+
+export type CodeFixEdit = PrependTextCodeFixEdit | ReplaceTextCodeFixEdit;
+
+export interface PrependTextCodeFixEdit {
+  readonly kind: "prepend-text";
+  readonly text: string;
+  readonly pos: number;
+  readonly file: SourceFile;
+}
+
+export interface ReplaceTextCodeFixEdit extends TextRange {
+  readonly kind: "replace-text";
+  readonly text: string;
+  readonly file: SourceFile;
 }
 
 /**

packages/compiler/src/server/constants.ts

@@ -13,3 +13,7 @@ export const serverOptions: CompilerOptions = {
  * Time in milliseconds to wait after a file change before recompiling.
  */
 export const UPDATE_DEBOUNCE_TIME = 200;
+
+export const Commands = {
+  APPLY_CODE_FIX: "typespec.applyCodeFix",
+};

packages/compiler/src/server/server.ts

@@ -5,9 +5,11 @@ import { join } from "path";
 import { fileURLToPath } from "url";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import {
+  ApplyWorkspaceEditParams,
   ProposedFeatures,
   PublishDiagnosticsParams,
   TextDocuments,
+  WorkspaceEdit,
   createConnection,
 } from "vscode-languageserver/node.js";
 import { NodeHost } from "../core/node-host.js";
@@ -49,6 +51,9 @@ function main() {
     getOpenDocumentByURL(url: string) {
       return documents.get(url);
     },
+    applyEdit(paramOrEdit: ApplyWorkspaceEditParams | WorkspaceEdit) {
+      return connection.workspace.applyEdit(paramOrEdit);
+    },
   };
 
   const s = createServer(host);
@@ -90,6 +95,8 @@ function main() {
   connection.onDocumentHighlight(profile(s.findDocumentHighlight));
   connection.onHover(profile(s.getHover));
   connection.onSignatureHelp(profile(s.getSignatureHelp));
+  connection.onCodeAction(profile(s.getCodeActions));
+  connection.onExecuteCommand(profile(s.executeCommand));
   connection.languages.semanticTokens.on(profile(s.buildSemanticTokens));
 
   documents.onDidChangeContent(profile(s.checkChange));

packages/compiler/src/server/serverlib.ts

@@ -1,5 +1,8 @@
 import { TextDocument } from "vscode-languageserver-textdocument";
 import {
+  CodeAction,
+  CodeActionKind,
+  CodeActionParams,
   CompletionList,
   CompletionParams,
   DefinitionParams,
@@ -12,6 +15,7 @@ import {
   DocumentHighlightParams,
   DocumentSymbol,
   DocumentSymbolParams,
+  ExecuteCommandParams,
   FoldingRange,
   FoldingRangeParams,
   Hover,
@@ -42,6 +46,7 @@ import {
   WorkspaceFoldersChangeEvent,
 } from "vscode-languageserver/node.js";
 import { CharCode, codePointBefore, isIdentifierContinue } from "../core/charcode.js";
+import { resolveCodeFix } from "../core/code-fixes.js";
 import { compilerAssert, createSourceFile, getSourceLocation } from "../core/diagnostics.js";
 import { formatTypeSpec } from "../core/formatter.js";
 import { getTypeName } from "../core/helpers/type-name-utils.js";
@@ -51,9 +56,12 @@ import { Program } from "../core/program.js";
 import { skipTrivia, skipWhiteSpace } from "../core/scanner.js";
 import {
   AugmentDecoratorStatementNode,
+  CodeFix,
+  CodeFixEdit,
   CompilerHost,
   DecoratorDeclarationStatementNode,
   DecoratorExpressionNode,
+  Diagnostic,
   DiagnosticTarget,
   IdentifierNode,
   Node,
@@ -67,6 +75,7 @@ import { getNormalizedRealPath, getSourceFileKindFromExt } from "../core/util.js
 import { getSemanticTokens } from "./classify.js";
 import { createCompileService } from "./compile-service.js";
 import { resolveCompletion } from "./completion.js";
+import { Commands } from "./constants.js";
 import { createFileService } from "./file-service.js";
 import { createFileSystemCache } from "./file-system-cache.js";
 import { getPositionBeforeTrivia } from "./server-utils.js";
@@ -104,6 +113,8 @@ export function createServer(host: ServerHost): Server {
     serverHost: host,
     log,
   });
+  const currentCodeActions = new Map<string, Map<string, [CodeAction, CodeFix]>>();
+  let codeFixCounter = 0;
   compileService.on("compileEnd", (result) => reportDiagnostics(result));
 
   let workspaceFolders: ServerWorkspaceFolder[] = [];
@@ -137,6 +148,8 @@ export function createServer(host: ServerHost): Server {
     getHover,
     getSignatureHelp,
     getDocumentSymbols,
+    getCodeActions,
+    executeCommand,
     log,
   };
 
@@ -172,6 +185,12 @@ export function createServer(host: ServerHost): Server {
         triggerCharacters: ["(", ",", "<"],
         retriggerCharacters: [")"],
       },
+      codeActionProvider: {
+        codeActionKinds: ["quickfix"],
+      },
+      executeCommandProvider: {
+        commands: [Commands.APPLY_CODE_FIX],
+      },
     };
 
     if (params.capabilities.workspace?.workspaceFolders) {
@@ -339,7 +358,7 @@ export function createServer(host: ServerHost): Server {
     // as we must send an empty array when a file has no diagnostics or else
     // stale diagnostics from a previous run will stick around in the IDE.
     //
-    const diagnosticMap: Map<TextDocument, VSDiagnostic[]> = new Map();
+    const diagnosticMap: Map<TextDocument, [VSDiagnostic, Diagnostic][]> = new Map();
     diagnosticMap.set(document, []);
     for (const each of program.sourceFiles.values()) {
       const document = (each.file as ServerSourceFile)?.document;
@@ -380,11 +399,34 @@ export function createServer(host: ServerHost): Server {
         diagnostics,
         "Diagnostic reported against a source file that was not added to the program."
       );
-      diagnostics.push(diagnostic);
+      diagnostics.push([diagnostic, each]);
     }
 
     for (const [document, diagnostics] of diagnosticMap) {
-      sendDiagnostics(document, diagnostics);
+      const documentCodeActions = new Map<string, [CodeAction, CodeFix]>();
+
+      for (const [vsDiag, tspDiag] of diagnostics) {
+        if (tspDiag.codefixes === undefined) {
+          continue;
+        }
+        for (const fix of tspDiag.codefixes) {
+          const id = `${fix.id}-${codeFixCounter++}`;
+          const codeAction: CodeAction = {
+            ...CodeAction.create(
+              fix.label,
+              { title: fix.label, command: Commands.APPLY_CODE_FIX, arguments: [document.uri, id] },
+              CodeActionKind.QuickFix
+            ),
+            diagnostics: [vsDiag],
+          };
+          documentCodeActions.set(id, [codeAction, fix]);
+        }
+      }
+      currentCodeActions.set(document.uri, documentCodeActions);
+      sendDiagnostics(
+        document,
+        diagnostics.map((x) => x[0])
+      );
     }
   }
 
@@ -734,6 +776,41 @@ export function createServer(host: ServerHost): Server {
     return builder.build();
   }
 
+  async function getCodeActions(params: CodeActionParams): Promise<CodeAction[]> {
+    const existing = currentCodeActions.get(params.textDocument.uri);
+    if (!existing) {
+      return [];
+    }
+
+    return [...existing.values()].map((x) => x[0]);
+  }
+
+  async function executeCommand(params: ExecuteCommandParams) {
+    if (params.command === Commands.APPLY_CODE_FIX) {
+      const [documentUri, id] = params.arguments ?? [];
+      if (documentUri && id) {
+        const codeFix = currentCodeActions.get(documentUri)?.get(id)?.[1];
+        console.log("Will apply ", documentUri, id, currentCodeActions.get(documentUri), codeFix);
+        if (codeFix) {
+          const edits = await resolveCodeFix(codeFix);
+          const vsEdits = convertCodeFixEdits(edits);
+          await host.applyEdit({ changes: { [documentUri]: vsEdits } });
+        }
+      }
+    }
+  }
+  function convertCodeFixEdits(edits: CodeFixEdit[]): TextEdit[] {
+    return edits.map(convertCodeFixEdit);
+  }
+  function convertCodeFixEdit(edit: CodeFixEdit): TextEdit {
+    switch (edit.kind) {
+      case "prepend-text":
+        return TextEdit.insert(edit.file.getLineAndCharacterOfPosition(edit.pos), edit.text);
+      case "replace-text":
+        return TextEdit.replace(getRange(edit, edit.file), edit.text);
+    }
+  }
+
   function documentClosed(change: TextDocumentChangeEvent<TextDocument>) {
     // clear diagnostics on file close
     sendDiagnostics(change.document, []);

packages/compiler/src/server/types.ts

@@ -1,4 +1,8 @@
 import {
+  ApplyWorkspaceEditParams,
+  ApplyWorkspaceEditResult,
+  CodeAction,
+  CodeActionParams,
   CompletionList,
   CompletionParams,
   DefinitionParams,
@@ -8,6 +12,7 @@ import {
   DocumentHighlightParams,
   DocumentSymbol,
   DocumentSymbolParams,
+  ExecuteCommandParams,
   FoldingRange,
   FoldingRangeParams,
   Hover,
@@ -40,6 +45,9 @@ export interface ServerHost {
   readonly getOpenDocumentByURL: (url: string) => TextDocument | undefined;
   readonly sendDiagnostics: (params: PublishDiagnosticsParams) => void;
   readonly log: (message: string) => void;
+  readonly applyEdit: (
+    paramOrEdit: ApplyWorkspaceEditParams | WorkspaceEdit
+  ) => Promise<ApplyWorkspaceEditResult>;
 }
 
 export interface CompileResult {
@@ -71,6 +79,8 @@ export interface Server {
   getFoldingRanges(getFoldingRanges: FoldingRangeParams): Promise<FoldingRange[]>;
   getDocumentSymbols(params: DocumentSymbolParams): Promise<DocumentSymbol[]>;
   documentClosed(change: TextDocumentChangeEvent<TextDocument>): void;
+  getCodeActions(params: CodeActionParams): Promise<CodeAction[]>;
+  executeCommand(params: ExecuteCommandParams): Promise<void>;
   log(message: string, details?: any): void;
 }