Stop preventing extraction when a type parameter wouldn't bind

...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 #18142

Author: amcasey

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;|]
 }`);
     });
 

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 });

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;
+}