Fixed an issue that resulted in an unnecessary use of memory when transforming certain types that include TypeVars.

msfterictraut · msfterictraut · commit 523762dfea89 · 2023-04-01T22:59:24.000-07:00
diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
@@ -10879,34 +10879,36 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
             for (let i = 0; i < passCount; i++) {
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
-                        if (argParam.requiresTypeVarMatching) {
-                            // Populate the typeVarContext for the argument. If the argument
-                            // is an overload function, skip it during the first pass
-                            // because the selection of the proper overload may depend
-                            // on type arguments supplied by other function arguments.
-                            // Set useNarrowBoundOnly to true the first time through
-                            // the loop if we're going to go through the loop multiple
-                            // times.
-                            const argResult = validateArgType(
-                                argParam,
-                                typeVarContext,
-                                { type, isIncomplete: matchResults.isTypeIncomplete },
-                                skipUnknownArgCheck,
-                                /* skipOverloadArg */ i === 0,
-                                /* useNarrowBoundOnly */ passCount > 1 && i === 0,
-                                typeCondition
-                            );
+                        if (!argParam.requiresTypeVarMatching) {
+                            return;
+                        }
 
-                            if (argResult.isTypeIncomplete) {
-                                isTypeIncomplete = true;
-                            }
+                        // Populate the typeVarContext for the argument. If the argument
+                        // is an overload function, skip it during the first pass
+                        // because the selection of the proper overload may depend
+                        // on type arguments supplied by other function arguments.
+                        // Set useNarrowBoundOnly to true the first time through
+                        // the loop if we're going to go through the loop multiple
+                        // times.
+                        const argResult = validateArgType(
+                            argParam,
+                            typeVarContext,
+                            { type, isIncomplete: matchResults.isTypeIncomplete },
+                            skipUnknownArgCheck,
+                            /* skipOverloadArg */ i === 0,
+                            /* useNarrowBoundOnly */ passCount > 1 && i === 0,
+                            typeCondition
+                        );
 
-                            // If we skipped a overload arg during the first pass,
-                            // add another pass to ensure that we handle all of the
-                            // type variables.
-                            if (i === 0 && argResult.skippedOverloadArg) {
-                                passCount++;
-                            }
+                        if (argResult.isTypeIncomplete) {
+                            isTypeIncomplete = true;
+                        }
+
+                        // If we skipped a overload arg during the first pass,
+                        // add another pass to ensure that we handle all of the
+                        // type variables.
+                        if (i === 0 && argResult.skippedOverloadArg) {
+                            passCount++;
                         }
                     });
                 });
diff --git a/packages/pyright-internal/src/analyzer/typeUtils.ts b/packages/pyright-internal/src/analyzer/typeUtils.ts
@@ -2925,7 +2925,7 @@ class TypeVarTransformer {
     }
 
     transformTypeVar(typeVar: TypeVarType, recursionCount: number): Type | undefined {
-        return typeVar;
+        return undefined;
     }
 
     transformTupleTypeVar(paramSpec: TypeVarType, recursionCount: number): TupleTypeArgument[] | undefined {

Original file line number	Diff line number	Diff line change
`@@ -2925,7 +2925,7 @@ class TypeVarTransformer {`
`2925`	`2925`	`}`
`2926`	`2926`
`2927`	`2927`	`transformTypeVar(typeVar: TypeVarType, recursionCount: number): Type \| undefined {`
`2928`		`- return typeVar;`
	`2928`	`+ return undefined;`
`2929`	`2929`	`}`
`2930`	`2930`
`2931`	`2931`	`transformTupleTypeVar(paramSpec: TypeVarType, recursionCount: number): TupleTypeArgument[] \| undefined {`