Refactor refactor

src/server/client.ts

@@ -719,20 +719,42 @@ namespace ts.server {
             return response.body;
         }
 
-        getRefactorCodeActions(
+        getEditsForRefactor(
             fileName: string,
             _formatOptions: FormatCodeSettings,
             positionOrRange: number | TextRange,
-            refactorName: string) {
+            refactorName: string,
+            actionName: string): RefactorEditInfo {
 
-            const args = this.createFileLocationOrRangeRequestArgs(positionOrRange, fileName) as protocol.GetRefactorCodeActionsRequestArgs;
-            args.refactorName = refactorName;
+            const args = this.createFileLocationOrRangeRequestArgs(positionOrRange, fileName) as protocol.GetEditsForRefactorRequestArgs;
+            args.refactor = refactorName;
+            args.action = actionName;
 
-            const request = this.processRequest<protocol.GetRefactorCodeActionsRequest>(CommandNames.GetRefactorCodeActions, args);
-            const response = this.processResponse<protocol.GetRefactorCodeActionsResponse>(request);
-            const codeActions = response.body.actions;
+            const request = this.processRequest<protocol.GetEditsForRefactorRequest>(CommandNames.GetEditsForRefactor, args);
+            const response = this.processResponse<protocol.GetEditsForRefactorResponse>(request);
+            const edits: FileTextChanges[] = this.convertCodeEditsToTextChanges(response.body.edits);
 
-            return map(codeActions, codeAction => this.convertCodeActions(codeAction, fileName));
+            const renameFilename: string | undefined = response.body.renameFilename;
+            let renameLocation: number | undefined = undefined;
+            if (renameFilename !== undefined) {
+                renameLocation = this.lineOffsetToPosition(renameFilename, response.body.renameLocation);
+            }
+
+            return {
+                edits,
+                renameFilename,
+                renameLocation
+            };
+        }
+
+        private convertCodeEditsToTextChanges(edits: ts.server.protocol.FileCodeEdits[]): FileTextChanges[] {
+            return edits.map(edit => {
+                const fileName = edit.fileName;
+                return {
+                    fileName,
+                    textChanges: edit.textChanges.map(t => this.convertTextChangeToCodeEdit(t, fileName))
+                };
+            });
         }
 
         convertCodeActions(entry: protocol.CodeAction, fileName: string): CodeAction {

src/server/protocol.ts

@@ -98,8 +98,11 @@ namespace ts.server.protocol {
         GetSupportedCodeFixes = "getSupportedCodeFixes",
 
         GetApplicableRefactors = "getApplicableRefactors",
-        GetRefactorCodeActions = "getRefactorCodeActions",
-        GetRefactorCodeActionsFull = "getRefactorCodeActions-full",
+        GetEditsForRefactor = "getEditsForRefactor",
+        /* @internal */
+        GetEditsForRefactorFull = "getEditsForRefactor-full",
+
+        // NOTE: If updating this, be sure to also update `allCommandNames` in `harness/unittests/session.ts`.
     }
 
     /**
@@ -401,52 +404,98 @@ namespace ts.server.protocol {
 
     export type FileLocationOrRangeRequestArgs = FileLocationRequestArgs | FileRangeRequestArgs;
 
+    /**
+     * Request refactorings at a given position or selection area.
+     */
     export interface GetApplicableRefactorsRequest extends Request {
         command: CommandTypes.GetApplicableRefactors;
         arguments: GetApplicableRefactorsRequestArgs;
     }
-
     export type GetApplicableRefactorsRequestArgs = FileLocationOrRangeRequestArgs;
 
-    export interface ApplicableRefactorInfo {
-        name: string;
-        description: string;
-    }
-
+    /**
+     * Response is a list of available refactorings.
+     * Each refactoring exposes 1 or more "Actions"; a user selects one action to invoke a refactoring
+     */
     export interface GetApplicableRefactorsResponse extends Response {
         body?: ApplicableRefactorInfo[];
     }
 
-    export interface GetRefactorCodeActionsRequest extends Request {
-        command: CommandTypes.GetRefactorCodeActions;
-        arguments: GetRefactorCodeActionsRequestArgs;
+    /**
+     * A set of one or more available refactoring actions, grouped under a parent refactoring.
+     */
+    export interface ApplicableRefactorInfo {
+        /**
+         * The programmatic name of the refactoring
+         */
+        name: string;
+        /**
+         * A description of this refactoring category to show to the user.
+         * If the refactoring gets inlined (see below), this text will not be visible.
+         */
+        description: string;
+        /**
+         * Inlineable refactorings can have their actions hoisted out to the top level
+         * of a context menu. Non-inlineanable refactorings should always be shown inside
+         * their parent grouping.
+         *
+         * If not specified, this value is assumed to be 'true'
+         */
+        inlineable?: boolean;
+
+        actions: RefactorActionInfo[];
     }
 
-    export type GetRefactorCodeActionsRequestArgs = FileLocationOrRangeRequestArgs & {
-        /* The kind of the applicable refactor */
-        refactorName: string;
+    /**
+     * Represents a single refactoring action - for example, the "Extract Method..." refactor might
+     * offer several actions, each corresponding to a surround class or closure to extract into.
+     */
+    export type RefactorActionInfo = {
+        /**
+         * The programmatic name of the refactoring action
+         */
+        name: string;
+
+        /**
+         * A description of this refactoring action to show to the user.
+         * If the parent refactoring is inlined away, this will be the only text shown,
+         * so this description should make sense by itself if the parent is inlineable=true
+         */
+        description: string;
     };
 
-    export type RefactorCodeActions = {
-        actions: protocol.CodeAction[];
-        renameLocation?: number
-    };
-
-    /* @internal */
-    export type RefactorCodeActionsFull = {
-        actions: ts.CodeAction[];
-        renameLocation?: number
-    };
-
-    export interface GetRefactorCodeActionsResponse extends Response {
-        body: RefactorCodeActions;
+    export interface GetEditsForRefactorRequest extends Request {
+        command: CommandTypes.GetEditsForRefactor;
+        arguments: GetEditsForRefactorRequestArgs;
     }
 
-    /* @internal */
-    export interface GetRefactorCodeActionsFullResponse extends Response {
-        body: RefactorCodeActionsFull;
+    /**
+     * Request the edits that a particular refactoring action produces.
+     * Callers must specify the name of the refactor and the name of the action.
+     */
+    export type GetEditsForRefactorRequestArgs = FileLocationOrRangeRequestArgs & {
+        /* The 'name' property from the refactoring that offered this action */
+        refactor: string;
+        /* The 'name' property from the refactoring action */
+        action: string;
+    };
+
+
+    export interface GetEditsForRefactorResponse extends Response {
+        body?: RefactorEditInfo;
     }
 
+    export type RefactorEditInfo = {
+        edits: FileCodeEdits[];
+
+        /**
+         * An optional location where the editor should start a rename operation once
+         * the refactoring edits have been applied
+         */
+        renameLocation?: Location;
+        renameFilename?: string;
+    };
+
     /**
      * Request for the available codefixes at a specific position.
      */

src/server/session.ts

@@ -1425,29 +1425,40 @@ namespace ts.server {
             return project.getLanguageService().getApplicableRefactors(file, position || textRange);
         }
 
-        private getRefactorCodeActions(args: protocol.GetRefactorCodeActionsRequestArgs, simplifiedResult: boolean): protocol.RefactorCodeActions | protocol.RefactorCodeActionsFull {
+        private getEditsForRefactor(args: protocol.GetEditsForRefactorRequestArgs, simplifiedResult: boolean): ts.RefactorEditInfo | protocol.RefactorEditInfo {
             const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args);
             const scriptInfo = project.getScriptInfoForNormalizedPath(file);
             const { position, textRange } = this.extractPositionAndRange(args, scriptInfo);
 
-            const result: ts.CodeAction[] = project.getLanguageService().getRefactorCodeActions(
+            const result = project.getLanguageService().getEditsForRefactor(
                 file,
                 this.projectService.getFormatCodeOptions(),
                 position || textRange,
-                args.refactorName
+                args.refactor,
+                args.action
             );
 
-            if (simplifiedResult) {
-                // Not full
+            if (result === undefined) {
                 return {
-                    actions: result.map(action => this.mapCodeAction(action, scriptInfo))
+                    edits: []
+                };
+            }
+
+            if (simplifiedResult) {
+                const file = result.renameFilename;
+                let location: ILineInfo | undefined  = undefined;
+                if (file !== undefined && result.renameLocation !== undefined) {
+                    const renameScriptInfo = project.getScriptInfoForNormalizedPath(toNormalizedPath(file));
+                    location = renameScriptInfo.positionToLineOffset(result.renameLocation);
+                }
+                return {
+                    renameLocation: location,
+                    renameFilename: file,
+                    edits: result.edits.map(change => this.mapTextChangesToCodeEdits(project, change))
                 };
             }
             else {
-                // Full
-                return {
-                    actions: result
-                };
+                return result;
             }
         }
 
@@ -1505,6 +1516,14 @@ namespace ts.server {
             };
         }
 
+        private mapTextChangesToCodeEdits(project: Project, textChanges: FileTextChanges): protocol.FileCodeEdits {
+            const scriptInfo = project.getScriptInfoForNormalizedPath(toNormalizedPath(textChanges.fileName));
+            return {
+                fileName: textChanges.fileName,
+                textChanges: textChanges.textChanges.map(textChange => this.convertTextChangeToCodeEdit(textChange, scriptInfo))
+            };
+        }
+
         private convertTextChangeToCodeEdit(change: ts.TextChange, scriptInfo: ScriptInfo): protocol.CodeEdit {
             return {
                 start: scriptInfo.positionToLineOffset(change.span.start),
@@ -1833,11 +1852,11 @@ namespace ts.server {
             [CommandNames.GetApplicableRefactors]: (request: protocol.GetApplicableRefactorsRequest) => {
                 return this.requiredResponse(this.getApplicableRefactors(request.arguments));
             },
-            [CommandNames.GetRefactorCodeActions]: (request: protocol.GetRefactorCodeActionsRequest) => {
-                return this.requiredResponse(this.getRefactorCodeActions(request.arguments, /*simplifiedResult*/ true));
+            [CommandNames.GetEditsForRefactor]: (request: protocol.GetEditsForRefactorRequest) => {
+                return this.requiredResponse(this.getEditsForRefactor(request.arguments, /*simplifiedResult*/ true));
             },
-            [CommandNames.GetRefactorCodeActionsFull]: (request: protocol.GetRefactorCodeActionsRequest) => {
-                return this.requiredResponse(this.getRefactorCodeActions(request.arguments, /*simplifiedResult*/ false));
+            [CommandNames.GetEditsForRefactorFull]: (request: protocol.GetEditsForRefactorRequest) => {
+                return this.requiredResponse(this.getEditsForRefactor(request.arguments, /*simplifiedResult*/ false));
             }
         });