Feature: Code fixes

.vscode/launch.json

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

packages/compiler/src/core/checker.ts

@@ -1,5 +1,6 @@
 import { $docFromComment, getIndexer } from "../lib/decorators.js";
 import { createSymbol, createSymbolTable } from "./binder.js";
+import { createChangeIdentifierCodeFix } from "./compiler-code-fixes/change-identifier.codefix.js";
 import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
 import { ProjectionError, compilerAssert, reportDeprecated } from "./diagnostics.js";
 import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-utils.js";
@@ -33,6 +34,7 @@ import {
   AugmentDecoratorStatementNode,
   BooleanLiteral,
   BooleanLiteralNode,
+  CodeFix,
   DecoratedType,
   Decorator,
   DecoratorApplication,
@@ -2314,12 +2316,26 @@ export function createChecker(program: Program): Checker {
 
     if (mapper === undefined) {
       reportCheckerDiagnostic(
-        createDiagnostic({ code: "unknown-identifier", format: { id: node.sv }, target: node })
+        createDiagnostic({
+          code: "unknown-identifier",
+          format: { id: node.sv },
+          target: node,
+          codefixes: getCodefixesForUnknownIdentifier(node),
+        })
       );
     }
     return undefined;
   }
 
+  function getCodefixesForUnknownIdentifier(node: IdentifierNode): CodeFix[] | undefined {
+    switch (node.sv) {
+      case "number":
+        return [createChangeIdentifierCodeFix(node, "float64")];
+      default:
+        return undefined;
+    }
+  }
+
   function resolveTypeReferenceSym(
     node: TypeReferenceNode | MemberExpressionNode | IdentifierNode,
     mapper: TypeMapper | undefined,

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/change-identifier.codefix.ts

@@ -0,0 +1,13 @@
+import { defineCodeFix, getSourceLocation } from "../diagnostics.js";
+import type { IdentifierNode } from "../types.js";
+
+export function createChangeIdentifierCodeFix(node: IdentifierNode, newIdentifier: string) {
+  return defineCodeFix({
+    id: "change-identifier",
+    label: `Change ${node.sv} to ${newIdentifier}`,
+    fix: (context) => {
+      const location = getSourceLocation(node);
+      return context.replaceText(location, newIdentifier);
+    },
+  });
+}

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/diagnostic-creator.ts

@@ -55,6 +55,7 @@ export function createDiagnosticCreator<T extends { [code: string]: DiagnosticMe
       severity: diagnosticDef.severity,
       message: messageStr,
       target: diagnostic.target,
+      codefixes: diagnostic.codefixes,
     };
   }
 

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;
 }
 
 /**
@@ -1994,6 +2021,7 @@ export type DiagnosticReportWithoutTarget<
 > = {
   code: C;
   messageId?: M;
+  readonly codefixes?: readonly CodeFix[];
 } & DiagnosticFormat<T, C, M>;
 
 export type DiagnosticReport<

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));