Extract refineNode into its own function

amcasey · amcasey · commit e4d5d1c16d88 · 2017-10-24T11:33:30.000-07:00
diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts
@@ -244,43 +244,52 @@ namespace ts.refactor.extractSymbol {
             return { targetRange: { range: statements, facts: rangeFacts, declarations } };
         }
 
-        // We have a single node (start)
-        let node = start;
+        if (isReturnStatement(start) && !start.expression) {
+            // Makes no sense to extract an expression-less return statement.
+            return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.CannotExtractRange)] };
+        }
 
-        if (isReturnStatement(start)) {
-            if (!start.expression) {
-                // Makes no sense to extract an expression-less return statement.
-                return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.CannotExtractRange)] };
-            }
+        // We have a single node (start)
+        const node = refineNode(start);
 
-            node = start.expression;
+        const errors = checkRootNode(node) || checkNode(node);
+        if (errors) {
+            return { errors };
         }
-        else if (isVariableStatement(start)) {
-            let numInitializers = 0;
-            let lastInitializer: Expression | undefined = undefined;
-            for (const declaration of start.declarationList.declarations) {
-                if (declaration.initializer) {
-                    numInitializers++;
-                    lastInitializer = declaration.initializer;
+        return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations } };
+
+        /**
+         * Attempt to refine the extraction node (generally, by shrinking it) to produce better results.
+         * @param node The unrefined extraction node.
+         */
+        function refineNode(node: Node) {
+            if (isReturnStatement(node)) {
+                if (node.expression) {
+                    return node.expression;
                 }
             }
-
-            if (numInitializers === 1) {
-                node = lastInitializer;
+            else if (isVariableStatement(node)) {
+                let numInitializers = 0;
+                let lastInitializer: Expression | undefined = undefined;
+                for (const declaration of node.declarationList.declarations) {
+                    if (declaration.initializer) {
+                        numInitializers++;
+                        lastInitializer = declaration.initializer;
+                    }
+                }
+                if (numInitializers === 1) {
+                    return lastInitializer;
+                }
+                // No special handling if there are multiple initializers.
             }
-            // No special handling if there are multiple initializers.
-        }
-        else if (isVariableDeclaration(node)) {
-            if (node.initializer) {
-                node = node.initializer;
+            else if (isVariableDeclaration(node)) {
+                if (node.initializer) {
+                    return node.initializer;
+                }
             }
-        }
 
-        const errors = checkRootNode(node) || checkNode(node);
-        if (errors) {
-            return { errors };
+            return node;
         }
-        return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations } };
 
         function checkRootNode(node: Node): Diagnostic[] | undefined {
             if (isIdentifier(isExpressionStatement(node) ? node.expression : node)) {
