Stop preventing extraction when a type parameter wouldn't bind

amcasey · amcasey · commit 255951c270b1 · 2017-09-13T13:35:05.000-07:00
...correctly in a containing scope. It's not an issue because we'll just declare a corresponding type parameter on the extracted function and pass the original as a type argument. Fixes microsoft#18142
diff --git a/src/harness/unittests/extractMethods.ts b/src/harness/unittests/extractMethods.ts
@@ -728,6 +728,11 @@ function parseUnaryExpression(operator: string): UnaryExpression {
 
 function parsePrimaryExpression(): any {
     throw "Not implemented";
+}`);
+        // Type parameter as declared type
+        testExtractMethod("extractMethod30",
+            `function F<T>() {
+    [#|let t: T;|]
 }`);
     });
 
diff --git a/src/services/refactors/extractMethod.ts b/src/services/refactors/extractMethod.ts
@@ -1222,7 +1222,11 @@ namespace ts.refactor.extractMethod {
                         substitutionsPerScope[i].set(symbolId, substitution);
                     }
                     else if (isTypeName) {
-                        errorsPerScope[i].push(createDiagnosticForNode(identifier, Messages.TypeWillNotBeVisibleInTheNewScope));
+                        // If the symbol is a type parameter that won't be in scope, we'll pass it as a type argument
+                        // so there's no problem.
+                        if (!(symbol.flags & SymbolFlags.TypeParameter)) {
+                            errorsPerScope[i].push(createDiagnosticForNode(identifier, Messages.TypeWillNotBeVisibleInTheNewScope));
+                        }
                     }
                     else {
                         usagesPerScope[i].usages.set(identifier.text as string, { usage, symbol, node: identifier });
diff --git a/tests/baselines/reference/extractMethod/extractMethod30.ts b/tests/baselines/reference/extractMethod/extractMethod30.ts
@@ -0,0 +1,19 @@
+// ==ORIGINAL==
+function F<T>() {
+    let t: T;
+}
+// ==SCOPE::inner function in function 'F'==
+function F<T>() {
+    /*RENAME*/newFunction();
+
+    function newFunction() {
+        let t: T;
+    }
+}
+// ==SCOPE::function in global scope==
+function F<T>() {
+    /*RENAME*/newFunction<T>();
+}
+function newFunction<T>() {
+    let t: T;
+}

Original file line number	Diff line number	Diff line change
`@@ -1222,7 +1222,11 @@ namespace ts.refactor.extractMethod {`
`1222`	`1222`	`substitutionsPerScope[i].set(symbolId, substitution);`
`1223`	`1223`	`}`
`1224`	`1224`	`else if (isTypeName) {`
`1225`		`- errorsPerScope[i].push(createDiagnosticForNode(identifier, Messages.TypeWillNotBeVisibleInTheNewScope));`
	`1225`	`+ // If the symbol is a type parameter that won't be in scope, we'll pass it as a type argument`
	`1226`	`+ // so there's no problem.`
	`1227`	`+ if (!(symbol.flags & SymbolFlags.TypeParameter)) {`
	`1228`	`+ errorsPerScope[i].push(createDiagnosticForNode(identifier, Messages.TypeWillNotBeVisibleInTheNewScope));`
	`1229`	`+ }`
`1226`	`1230`	`}`
`1227`	`1231`	`else {`
`1228`	`1232`	`usagesPerScope[i].usages.set(identifier.text as string, { usage, symbol, node: identifier });`