CodeMapper support

Author: zkat

src/server/protocol.ts

@@ -173,6 +173,7 @@ export const enum CommandTypes {
     ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls",
     ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls",
     ProvideInlayHints = "provideInlayHints",
+    MapCode = "mapCode",
 }
 
 /**
@@ -2687,6 +2688,32 @@ export interface InlayHintsResponse extends Response {
     body?: InlayHintItem[];
 }
 
+export interface MapCodeRequestArgs extends FileRequestArgs {
+    /// The specific code to map/insert/replace in the file.
+    contents: string[];
+
+    /// Optional contextual information to improve mapping results based on heuristics.
+    context?: MapCodeContext;
+}
+
+export interface MapCodeContext {
+    /// The currently selected/contextual spans to use for mapping heuristics.
+    /// Lower-index items will be given higher priority.
+    selected?: TextSpan[];
+
+    /// Changes to apply to the workspace before calculating the mapped edits.
+    updates?: FileCodeEdits[];
+}
+
+export interface MapCodeRequest extends Request {
+    command: CommandTypes.MapCode,
+    arguments: MapCodeRequestArgs;
+}
+
+export interface MapCodeResponse extends Response {
+    body: FileCodeEdits[]
+}
+
 /**
  * Synchronous request for semantic diagnostics of one file.
  */

src/server/session.ts

@@ -1887,6 +1887,45 @@ export class Session<TMessage = string> implements EventSender {
         });
     }
 
+    private mapCode(args: protocol.MapCodeRequestArgs): protocol.FileCodeEdits[] {
+        const { file, project } = this.getFileAndProject(args);
+        const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file)!;
+        const selected = args.context?.selected?.map(span => {
+            const start = scriptInfo.lineOffsetToPosition(span.start.line, span.start.offset);
+            const end = scriptInfo.lineOffsetToPosition(span.end.line, span.end.offset);
+            return {
+                start,
+                length: end - start,
+            };
+        });
+        const updates = args.context?.updates?.map(edit => {
+            return {
+                fileName: edit.fileName,
+                textChanges: edit.textChanges.map(({ start, end, newText }) => {
+                    const newStart = scriptInfo.lineOffsetToPosition(start.line, start.offset);
+                    const newEnd = scriptInfo.lineOffsetToPosition(end.line, end.offset);
+                    return {
+                        span: { start: newStart, length: newEnd - newStart },
+                        newText,
+                    };
+                }),
+            };
+        });
+        return project.getLanguageService().mapCode(file, args.contents, selected, updates)?.map(change => {
+            return {
+                fileName: change.fileName,
+                textChanges: change.textChanges.map(({ span, newText }) => {
+                    const newSpan = toProtocolTextSpan(span, scriptInfo);
+                    return {
+                        start: newSpan.start,
+                        end: newSpan.end,
+                        newText
+                    };
+                }),
+            };
+        });
+    }
+
     private setCompilerOptionsForInferredProjects(args: protocol.SetCompilerOptionsForInferredProjectsArgs): void {
         this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);
     }
@@ -3556,6 +3595,9 @@ export class Session<TMessage = string> implements EventSender {
         [protocol.CommandTypes.ProvideInlayHints]: (request: protocol.InlayHintsRequest) => {
             return this.requiredResponse(this.provideInlayHints(request.arguments));
         },
+        [protocol.CommandTypes.MapCode]: (request: protocol.MapCodeRequest) => {
+            return this.requiredResponse(this.mapCode(request.arguments));
+        },
     }));
 
     public addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse) {

src/services/_namespaces/ts.MapCode.ts

@@ -0,0 +1,4 @@
+/* Generated file to emulate the ts.MapCode namespace. */
+
+export * from "../mapCode";
+

src/services/_namespaces/ts.ts

@@ -33,6 +33,8 @@ import * as GoToDefinition from "./ts.GoToDefinition";
 export { GoToDefinition };
 import * as InlayHints from "./ts.InlayHints";
 export { InlayHints };
+import * as MapCode from "./ts.MapCode";
+export { MapCode };
 import * as JsDoc from "./ts.JsDoc";
 export { JsDoc };
 import * as NavigateTo from "./ts.NavigateTo";

src/services/mapCode.ts

@@ -0,0 +1,23 @@
+import {
+    FileTextChanges,
+    Program,
+    SourceFile,
+    textChanges,
+    TextSpan,
+} from "./_namespaces/ts";
+
+// useful stuff:
+// textChanges.ChangeTracker - lots of methods for inserting nodes in the right place.
+// textChanges.ChangeTracker.pushRaw() - to push `updates` before running our analysis.
+
+/** @internal */
+export function mapCode(
+    file: SourceFile,
+    program: Program,
+    contents: string[],
+    selected?: TextSpan[],
+    updates?: FileTextChanges[]
+): FileTextChanges[] {
+    const checker = program.getTypeChecker();
+    return [];
+}

src/services/services.ts

@@ -207,6 +207,7 @@ import {
     LinkedEditingInfo,
     LiteralType,
     map,
+    MapCode,
     mapDefined,
     MapLike,
     mapOneOrMany,
@@ -3070,6 +3071,12 @@ export function createLanguageService(
         return InlayHints.provideInlayHints(getInlayHintsContext(sourceFile, span, preferences));
     }
 
+    function mapCode(fileName: string, contents: string[], selected?: TextSpan[], updates?: FileTextChanges[]): FileTextChanges[] {
+        synchronizeHostData();
+        const sourceFile = getValidSourceFile(fileName);
+        return MapCode.mapCode(sourceFile, program, contents, selected, updates);
+    }
+
     const ls: LanguageService = {
         dispose,
         cleanupSemanticCache,
@@ -3140,6 +3147,7 @@ export function createLanguageService(
         uncommentSelection,
         provideInlayHints,
         getSupportedCodeFixes,
+        mapCode,
     };
 
     switch (languageServiceMode) {

src/services/types.ts

@@ -676,6 +676,8 @@ export interface LanguageService {
 
     getSupportedCodeFixes(fileName?: string): readonly string[];
 
+    mapCode(fileName: string, contents: string[], selected?: TextSpan[], updates?: FileTextChanges[]): FileTextChanges[];
+
     dispose(): void;
 }