Refactor refactor

src/services/refactorProvider.ts

@@ -8,10 +8,10 @@ namespace ts {
         description: string;
 
         /** Compute the associated code actions */
-        getCodeActions(context: RefactorContext): CodeAction[];
+        getEditsForAction(context: RefactorContext, actionName: string): RefactorEditInfo | undefined;
 
-        /** A fast syntactic check to see if the refactor is applicable at given position. */
-        isApplicable(context: RefactorContext): boolean;
+        /** Compute (quickly) which actions are available here */
+        getAvailableActions(context: RefactorContext): ApplicableRefactorInfo[] | undefined;
     }
 
     export interface RefactorContext {
@@ -34,7 +34,6 @@ namespace ts {
         }
 
         export function getApplicableRefactors(context: RefactorContext): ApplicableRefactorInfo[] | undefined {
-
             let results: ApplicableRefactorInfo[];
             const refactorList: Refactor[] = [];
             refactors.forEach(refactor => {
@@ -44,16 +43,17 @@ namespace ts {
                 if (context.cancellationToken && context.cancellationToken.isCancellationRequested()) {
                     return results;
                 }
-                if (refactor.isApplicable(context)) {
-                    (results || (results = [])).push({ name: refactor.name, description: refactor.description });
+                const infos = refactor.getAvailableActions(context);
+                if (infos && infos.length) {
+                    (results || (results = [])).push(...infos);
                 }
             }
             return results;
         }
 
-        export function getRefactorCodeActions(context: RefactorContext, refactorName: string): CodeAction[] | undefined {
+        export function getEditsForRefactor(context: RefactorContext, refactorName: string, actionName: string): RefactorEditInfo | undefined {
             const refactor = refactors.get(refactorName);
-            return refactor && refactor.getCodeActions(context);
+            return refactor && refactor.getEditsForAction(context, actionName);
         }
     }
 }

src/services/refactors/convertFunctionToEs6Class.ts

@@ -1,16 +1,18 @@
 /* @internal */
 
 namespace ts.refactor {
+    const actionName = "convert";
+
     const convertFunctionToES6Class: Refactor = {
         name: "Convert to ES2015 class",
         description: Diagnostics.Convert_function_to_an_ES2015_class.message,
-        getCodeActions,
-        isApplicable
+        getEditsForAction,
+        getAvailableActions
     };
 
     registerRefactor(convertFunctionToES6Class);
 
-    function isApplicable(context: RefactorContext): boolean {
+    function getAvailableActions(context: RefactorContext): ApplicableRefactorInfo[] {
         const start = context.startPosition;
         const node = getTokenAtPosition(context.file, start, /*includeJsDocComment*/ false);
         const checker = context.program.getTypeChecker();
@@ -20,10 +22,28 @@ namespace ts.refactor {
             symbol = (symbol.valueDeclaration as VariableDeclaration).initializer.symbol;
         }
 
-        return symbol && symbol.flags & SymbolFlags.Function && symbol.members && symbol.members.size > 0;
+        if (symbol && symbol.flags & SymbolFlags.Function && symbol.members && symbol.members.size > 0) {
+            return [
+                {
+                    name: convertFunctionToES6Class.name,
+                    description: convertFunctionToES6Class.description,
+                    actions: [
+                        {
+                            description: convertFunctionToES6Class.description,
+                            name: actionName
+                        }
+                    ]
+                }
+            ];
+        }
     }
 
-    function getCodeActions(context: RefactorContext): CodeAction[] | undefined {
+    function getEditsForAction(context: RefactorContext, action: string): RefactorEditInfo | undefined {
+        // Somehow wrong action got invoked?
+        if (actionName !== action) {
+            return undefined;
+        }
+
         const start = context.startPosition;
         const sourceFile = context.file;
         const checker = context.program.getTypeChecker();
@@ -35,7 +55,7 @@ namespace ts.refactor {
         const deletes: (() => any)[] = [];
 
         if (!(ctorSymbol.flags & (SymbolFlags.Function | SymbolFlags.Variable))) {
-            return [];
+            return undefined;
         }
 
         const ctorDeclaration = ctorSymbol.valueDeclaration;
@@ -63,7 +83,7 @@ namespace ts.refactor {
         }
 
         if (!newClassDeclaration) {
-            return [];
+            return undefined;
         }
 
         // Because the preceding node could be touched, we need to insert nodes before delete nodes.
@@ -72,10 +92,9 @@ namespace ts.refactor {
             deleteCallback();
         }
 
-        return [{
-            description: formatStringFromArgs(Diagnostics.Convert_function_0_to_class.message, [ctorSymbol.name]),
-            changes: changeTracker.getChanges()
-        }];
+        return {
+            edits: changeTracker.getChanges()
+        };
 
         function deleteNode(node: Node, inList = false) {
             if (deletedNodes.some(n => isNodeDescendantOf(node, n))) {

src/services/services.ts

@@ -1989,15 +1989,16 @@ namespace ts {
             return refactor.getApplicableRefactors(getRefactorContext(file, positionOrRange));
         }
 
-        function getRefactorCodeActions(
+        function getEditsForRefactor(
             fileName: string,
             formatOptions: FormatCodeSettings,
             positionOrRange: number | TextRange,
-            refactorName: string): CodeAction[] | undefined {
+            refactorName: string,
+            actionName: string): RefactorEditInfo {
 
             synchronizeHostData();
             const file = getValidSourceFile(fileName);
-            return refactor.getRefactorCodeActions(getRefactorContext(file, positionOrRange, formatOptions), refactorName);
+            return refactor.getEditsForRefactor(getRefactorContext(file, positionOrRange, formatOptions), refactorName, actionName);
         }
 
         return {
@@ -2005,8 +2006,6 @@ namespace ts {
             cleanupSemanticCache,
             getSyntacticDiagnostics,
             getSemanticDiagnostics,
-            getApplicableRefactors,
-            getRefactorCodeActions,
             getCompilerOptionsDiagnostics,
             getSyntacticClassifications,
             getSemanticClassifications,
@@ -2044,7 +2043,9 @@ namespace ts {
             getEmitOutput,
             getNonBoundSourceFile,
             getSourceFile,
-            getProgram
+            getProgram,
+            getApplicableRefactors,
+            getEditsForRefactor,
         };
     }
 

src/services/types.ts

@@ -261,8 +261,9 @@ namespace ts {
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
 
         getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[], formatOptions: FormatCodeSettings): CodeAction[];
+
         getApplicableRefactors(fileName: string, positionOrRaneg: number | TextRange): ApplicableRefactorInfo[];
-        getRefactorCodeActions(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string): CodeAction[] | undefined;
+        getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string): RefactorEditInfo | undefined;
 
         getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean): EmitOutput;
 
@@ -353,11 +354,60 @@ namespace ts {
         changes: FileTextChanges[];
     }
 
+    /**
+     * 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[];
     }
 
+    /**
+     * 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;
+    };
+
+    /**
+     * A set of edits to make in response to a refactor action, plus an optional
+     * location where renaming should be invoked from
+     */
+    export type RefactorEditInfo = {
+        edits: FileTextChanges[];
+        renameFilename?: string;
+        renameLocation?: number;
+    };
+
+
     export interface TextInsertion {
         newText: string;
         /** The position in newText the caret should point to after the insertion. */