Rename interface after extraction

src/editor/adapters/in-memory-editor.ts

@@ -118,6 +118,10 @@ class InMemoryEditor implements Editor {
     return Promise.resolve(choices[0]);
   }
 
+  moveCursorTo(_position: Position) {
+    return Promise.resolve();
+  }
+
   private setCodeMatrix(code: Code) {
     this.codeMatrix = code
       .split(LINE_SEPARATOR)

src/editor/adapters/vscode-editor.ts

@@ -98,6 +98,11 @@ class VSCodeEditor implements Editor {
   async askUser<T>(choices: Choice<T>[]) {
     return await vscode.window.showQuickPick(choices);
   }
+
+  moveCursorTo(position: Position) {
+    this.editor.selection = toVSCodeCursor(position);
+    return Promise.resolve();
+  }
 }
 
 function createSelectionFromVSCode(

src/editor/editor.ts

@@ -22,6 +22,7 @@ interface Editor {
   delegate(command: Command): Promise<void>;
   showError(reason: ErrorReason): Promise<void>;
   askUser<T>(choices: Choice<T>[]): Promise<Choice<T> | undefined>;
+  moveCursorTo(position: Position): Promise<void>;
 }
 
 type Modification = {

src/editor/position.ts

@@ -73,6 +73,10 @@ class Position {
     return new Position(this.line + lines, this.character);
   }
 
+  addCharacters(characters: number): Position {
+    return new Position(this.line, this.character + characters);
+  }
+
   putAtSameCharacter(position: Position): Position {
     return new Position(this.line, position.character);
   }

src/refactorings/extract-interface/extract-interface.test.ts

@@ -1,4 +1,5 @@
 import { Editor, ErrorReason, Code } from "../../editor/editor";
+import { Position } from "../../editor/position";
 import { Selection } from "../../editor/selection";
 import { InMemoryEditor } from "../../editor/adapters/in-memory-editor";
 import { testEach } from "../../tests-helpers";
@@ -215,6 +216,25 @@ interface Extracted {
     );
   });
 
+  it("should move cursor to extracted interface name", async () => {
+    const code = `class Position {
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  isEqualTo(position: Position): boolean {
+    return true;
+  }
+}`;
+    const editor = new InMemoryEditor(code);
+    const selection = Selection.cursorAt(0, 0);
+    const moveCursorTo = jest.spyOn(editor, "moveCursorTo");
+
+    await extractInterface(code, selection, editor);
+
+    expect(moveCursorTo).toBeCalledWith(new Position(10, 10));
+  });
+
   async function doExtractInterface(
     code: Code,
     selection: Selection

src/refactorings/extract-interface/extract-interface.ts

@@ -1,6 +1,8 @@
 import { Editor, Code, ErrorReason } from "../../editor/editor";
+import { Position } from "../../editor/position";
 import { Selection } from "../../editor/selection";
 import * as t from "../../ast";
+import { renameSymbol } from "../rename-symbol/rename-symbol";
 
 export { extractInterface, canExtractInterface };
 
@@ -17,6 +19,10 @@ async function extractInterface(
   }
 
   await editor.write(updatedCode.code);
+
+  await editor.moveCursorTo(updatedCode.interfaceIdentifierPosition);
+
+  await renameSymbol(editor);
 }
 
 function canExtractInterface(ast: t.AST, selection: Selection): boolean {
@@ -26,14 +32,33 @@ function canExtractInterface(ast: t.AST, selection: Selection): boolean {
   return result;
 }
 
-function updateCode(ast: t.AST, selection: Selection): t.Transformed {
-  return t.transformAST(
+function updateCode(
+  ast: t.AST,
+  selection: Selection
+): t.Transformed & { interfaceIdentifierPosition: Position } {
+  let interfaceIdentifierPosition: Position = selection.start;
+
+  const result = t.transformAST(
     ast,
     createVisitor(selection, (path, id, declaration) => {
+      if (t.isSelectableNode(path.node)) {
+        // "interface X" => 10 characters before "X"
+        const interfaceIdentifierOffset = 10;
+
+        interfaceIdentifierPosition = Position.fromAST(path.node.loc.end)
+          .putAtStartOfLine()
+          // New interface starts 2 lines after class declaration
+          .putAtNextLine()
+          .putAtNextLine()
+          .addCharacters(interfaceIdentifierOffset);
+      }
+
       path.node.implements = [t.classImplements(id)];
       path.insertAfter(declaration);
     })
   );
+
+  return { ...result, interfaceIdentifierPosition };
 }
 
 function createVisitor(