fixes(44110): allow "extract to inner function" refactoring inside function expression

src/services/refactors/extractSymbol.ts

@@ -215,7 +215,6 @@ namespace ts.refactor.extractSymbol {
         export const cannotExtractReadonlyPropertyInitializerOutsideConstructor = createMessage("Cannot move initialization of read-only class property outside of the constructor");
         export const cannotExtractAmbientBlock = createMessage("Cannot extract code from ambient contexts");
         export const cannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes");
-        export const cannotExtractToOtherFunctionLike = createMessage("Cannot extract method to a function-like scope that is not a function");
         export const cannotExtractToJSClass = createMessage("Cannot extract constant to a class scope in JS");
         export const cannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block");
     }
@@ -1624,10 +1623,7 @@ namespace ts.refactor.extractSymbol {
             usagesPerScope.push({ usages: new Map<string, UsageEntry>(), typeParameterUsages: new Map<string, TypeParameter>(), substitutions: new Map<string, Expression>() });
             substitutionsPerScope.push(new Map<string, Expression>());
 
-            functionErrorsPerScope.push(
-                isFunctionLikeDeclaration(scope) && scope.kind !== SyntaxKind.FunctionDeclaration
-                    ? [createDiagnosticForNode(scope, Messages.cannotExtractToOtherFunctionLike)]
-                    : []);
+            functionErrorsPerScope.push([]);
 
             const constantErrors = [];
             if (expressionDiagnostic) {

src/testRunner/unittests/services/extract/functions.ts

@@ -352,6 +352,11 @@ function parsePrimaryExpression(): any {
             `function F() {
     [#|function G() { }|]
 }`);
+        // Arrow function
+        testExtractFunction("extractFunction34",
+            `const F = () => {
+    [#|function G() { }|]
+};`);
 
         testExtractFunction("extractFunction_RepeatedSubstitution",
             `namespace X {

tests/baselines/reference/extractFunction/extractFunction10.ts

@@ -9,6 +9,21 @@ namespace A {
         }
     }
 }
+// ==SCOPE::Extract to inner function in method 'a'==
+namespace A {
+    export interface I { x: number };
+    class C {
+        a() {
+            let z = 1;
+            return /*RENAME*/newFunction();
+
+            function newFunction() {
+                let a1: I = { x: 1 };
+                return a1.x + 10;
+            }
+        }
+    }
+}
 // ==SCOPE::Extract to method in class 'C'==
 namespace A {
     export interface I { x: number };

tests/baselines/reference/extractFunction/extractFunction11.ts

@@ -11,6 +11,23 @@ namespace A {
         }
     }
 }
+// ==SCOPE::Extract to inner function in method 'a'==
+namespace A {
+    let y = 1;
+    class C {
+        a() {
+            let z = 1;
+            return /*RENAME*/newFunction();
+
+            function newFunction() {
+                let a1 = { x: 1 };
+                y = 10;
+                z = 42;
+                return a1.x + 10;
+            }
+        }
+    }
+}
 // ==SCOPE::Extract to method in class 'C'==
 namespace A {
     let y = 1;

tests/baselines/reference/extractFunction/extractFunction12.ts

@@ -13,6 +13,25 @@ namespace A {
         }
     }
 }
+// ==SCOPE::Extract to inner function in method 'a'==
+namespace A {
+    let y = 1;
+    class C {
+        b() {}
+        a() {
+            let z = 1;
+            return /*RENAME*/newFunction();
+
+            function newFunction() {
+                let a1 = { x: 1 };
+                y = 10;
+                z = 42;
+                this.b();
+                return a1.x + 10;
+            }
+        }
+    }
+}
 // ==SCOPE::Extract to method in class 'C'==
 namespace A {
     let y = 1;

tests/baselines/reference/extractFunction/extractFunction13.ts

@@ -14,6 +14,26 @@
         }
     }
 }
+// ==SCOPE::Extract to inner function in arrow function==
+<U1a, U1b>(u1a: U1a, u1b: U1b) => {
+    function F1<T1a, T1b>(t1a: T1a, t1b: T1b) {
+        <U2a, U2b>(u2a: U2a, u2b: U2b) => {
+            function F2<T2a, T2b>(t2a: T2a, t2b: T2b) {
+                <U3a, U3b>(u3a: U3a, u3b: U3b) => {
+                        /*RENAME*/newFunction();
+
+                    function newFunction() {
+                        t1a.toString();
+                        t2a.toString();
+                        u1a.toString();
+                        u2a.toString();
+                        u3a.toString();
+                    }
+                }
+            }
+        }
+    }
+}
 // ==SCOPE::Extract to inner function in function 'F2'==
 <U1a, U1b>(u1a: U1a, u1b: U1b) => {
     function F1<T1a, T1b>(t1a: T1a, t1b: T1b) {

tests/baselines/reference/extractFunction/extractFunction17.ts

@@ -4,6 +4,16 @@ class C<T1, T2> {
         /*[#|*/t1.toString()/*|]*/;
     }
 }
+// ==SCOPE::Extract to inner function in method 'M'==
+class C<T1, T2> {
+    M(t1: T1, t2: T2) {
+        /*RENAME*/newFunction();
+
+        function newFunction() {
+            t1.toString();
+        }
+    }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C<T1, T2> {
     M(t1: T1, t2: T2) {

tests/baselines/reference/extractFunction/extractFunction18.ts

@@ -4,6 +4,16 @@ class C {
         /*[#|*/t1.toString()/*|]*/;
     }
 }
+// ==SCOPE::Extract to inner function in method 'M'==
+class C {
+    M<T1, T2>(t1: T1, t2: T2) {
+        /*RENAME*/newFunction();
+
+        function newFunction() {
+            t1.toString();
+        }
+    }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M<T1, T2>(t1: T1, t2: T2) {

tests/baselines/reference/extractFunction/extractFunction20.js

@@ -5,6 +5,17 @@ const _ = class {
         return a1.x + 10;/*|]*/
     }
 }
+// ==SCOPE::Extract to inner function in method 'a'==
+const _ = class {
+    a() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            let a1 = { x: 1 };
+            return a1.x + 10;
+        }
+    }
+}
 // ==SCOPE::Extract to method in anonymous class expression==
 const _ = class {
     a() {

tests/baselines/reference/extractFunction/extractFunction20.ts

@@ -5,6 +5,17 @@ const _ = class {
         return a1.x + 10;/*|]*/
     }
 }
+// ==SCOPE::Extract to inner function in method 'a'==
+const _ = class {
+    a() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            let a1 = { x: 1 };
+            return a1.x + 10;
+        }
+    }
+}
 // ==SCOPE::Extract to method in anonymous class expression==
 const _ = class {
     a() {

tests/baselines/reference/extractFunction/extractFunction26.js

@@ -6,6 +6,18 @@ class C {
     }
     M3() { }
 }
+// ==SCOPE::Extract to inner function in method 'M2'==
+class C {
+    M1() { }
+    M2() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            return 1;
+        }
+    }
+    M3() { }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M1() { }

tests/baselines/reference/extractFunction/extractFunction26.ts

@@ -6,6 +6,18 @@ class C {
     }
     M3() { }
 }
+// ==SCOPE::Extract to inner function in method 'M2'==
+class C {
+    M1() { }
+    M2() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            return 1;
+        }
+    }
+    M3() { }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M1() { }

tests/baselines/reference/extractFunction/extractFunction27.js

@@ -7,6 +7,19 @@ class C {
     constructor() { }
     M3() { }
 }
+// ==SCOPE::Extract to inner function in method 'M2'==
+class C {
+    M1() { }
+    M2() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            return 1;
+        }
+    }
+    constructor() { }
+    M3() { }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M1() { }

tests/baselines/reference/extractFunction/extractFunction27.ts

@@ -7,6 +7,19 @@ class C {
     constructor() { }
     M3() { }
 }
+// ==SCOPE::Extract to inner function in method 'M2'==
+class C {
+    M1() { }
+    M2() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            return 1;
+        }
+    }
+    constructor() { }
+    M3() { }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M1() { }

tests/baselines/reference/extractFunction/extractFunction28.js

@@ -7,6 +7,19 @@ class C {
     M3() { }
     constructor() { }
 }
+// ==SCOPE::Extract to inner function in method 'M2'==
+class C {
+    M1() { }
+    M2() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            return 1;
+        }
+    }
+    M3() { }
+    constructor() { }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M1() { }

tests/baselines/reference/extractFunction/extractFunction28.ts

@@ -7,6 +7,19 @@ class C {
     M3() { }
     constructor() { }
 }
+// ==SCOPE::Extract to inner function in method 'M2'==
+class C {
+    M1() { }
+    M2() {
+        return /*RENAME*/newFunction();
+
+        function newFunction() {
+            return 1;
+        }
+    }
+    M3() { }
+    constructor() { }
+}
 // ==SCOPE::Extract to method in class 'C'==
 class C {
     M1() { }

tests/baselines/reference/extractFunction/extractFunction31.ts

@@ -10,6 +10,22 @@ namespace N {
         }/*|]*/
     }
 }
+// ==SCOPE::Extract to inner function in arrow function==
+namespace N {
+
+    export const value = 1;
+
+    () => {
+        var f: () => number;
+        /*RENAME*/newFunction();
+
+        function newFunction() {
+            f = function(): number {
+                return value;
+            };
+        }
+    }
+}
 // ==SCOPE::Extract to function in namespace 'N'==
 namespace N {
 

tests/baselines/reference/extractFunction/extractFunction32.ts

@@ -11,6 +11,23 @@ namespace N {
         }/*|]*/
     }
 }
+// ==SCOPE::Extract to inner function in arrow function==
+namespace N {
+
+    export const value = 1;
+
+    () => {
+        var c = /*RENAME*/newFunction()
+
+        function newFunction() {
+            return class {
+                M() {
+                    return value;
+                }
+            };
+        }
+    }
+}
 // ==SCOPE::Extract to function in namespace 'N'==
 namespace N {
 

tests/baselines/reference/extractFunction/extractFunction34.js

@@ -0,0 +1,20 @@
+// ==ORIGINAL==
+const F = () => {
+    /*[#|*/function G() { }/*|]*/
+};
+// ==SCOPE::Extract to inner function in arrow function==
+const F = () => {
+    /*RENAME*/newFunction();
+
+    function newFunction() {
+        function G() { }
+    }
+};
+// ==SCOPE::Extract to function in global scope==
+const F = () => {
+    /*RENAME*/newFunction();
+};
+
+function newFunction() {
+    function G() { }
+}