fixup! report error for unsolved type variables in function calls

Author: KotlinIsland

.basedpyright/baseline.json

@@ -297,6 +297,14 @@
                     "lineCount": 1
                 }
             },
+            {
+                "code": "reportUnsolvedTypeVar",
+                "range": {
+                    "startColumn": 4,
+                    "endColumn": 5,
+                    "lineCount": 7
+                }
+            },
             {
                 "code": "reportUnusedCallResult",
                 "range": {
@@ -305,6 +313,14 @@
                     "lineCount": 7
                 }
             },
+            {
+                "code": "reportUnsolvedTypeVar",
+                "range": {
+                    "startColumn": 4,
+                    "endColumn": 5,
+                    "lineCount": 6
+                }
+            },
             {
                 "code": "reportUnusedCallResult",
                 "range": {

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -12567,7 +12567,9 @@ export function createTypeEvaluator(
             eliminateUnsolvedInUnions = false;
         }
 
-        let specializedReturnType = solveAndApplyConstraints(returnType, constraints, {
+        // Solve constraints once and reuse the solution
+        const solution = solveConstraints(evaluatorInterface, constraints);
+        let specializedReturnType = applySolvedTypeVars(returnType, solution, {
             replaceUnsolved: {
                 scopeIds: getTypeVarScopeIds(type),
                 unsolvedExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
@@ -12604,13 +12606,14 @@ export function createTypeEvaluator(
         specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
 
         if (specializedInitSelfType) {
-            specializedInitSelfType = solveAndApplyConstraints(specializedInitSelfType, constraints);
+            specializedInitSelfType = applySolvedTypeVars(specializedInitSelfType, solution);
         }
 
         // check for unsolved type variables and report errors
         if (!argumentErrors && !isTypeIncomplete && type.shared.typeParams.length > 0) {
-            const solution = solveConstraints(evaluatorInterface, constraints);
             const solutionSet = solution.getMainSolutionSet();
+            const scopeIds = getTypeVarScopeIds(type);
+            const unsolvedExemptTypeVars = getUnknownExemptTypeVarsForReturnType(type, returnType);
 
             for (const typeParam of type.shared.typeParams) {
                 // skip type parameters that have explicit default values
@@ -12623,12 +12626,22 @@ export function createTypeEvaluator(
                     continue;
                 }
 
+                // only check type parameters that are in scope for this function
+                if (typeParam.priv.scopeId && scopeIds && !scopeIds.includes(typeParam.priv.scopeId)) {
+                    continue;
+                }
+
+                // skip type parameters that are exempt from being solved (e.g., they appear
+                // only in the return type as part of a returned callable)
+                if (unsolvedExemptTypeVars.some((exemptVar) => isTypeSame(exemptVar, typeParam))) {
+                    continue;
+                }
+
                 const solvedType = solutionSet.getType(typeParam);
 
-                // if there's no solution for this type parameter, report an error
                 if (!solvedType) {
                     addDiagnostic(
-                        DiagnosticRule.reportCallIssue,
+                        DiagnosticRule.reportUnsolvedTypeVar,
                         LocMessage.typeVarUnsolved().format({
                             name: typeParam.shared.name,
                         }),

packages/pyright-internal/src/common/configOptions.ts

@@ -427,6 +427,7 @@ export interface DiagnosticRuleSet {
     reportIncompatibleUnannotatedOverride: DiagnosticLevel;
     reportInvalidAbstractMethod: DiagnosticLevel;
     reportSelfClsDefault: DiagnosticLevel;
+    reportUnsolvedTypeVar: DiagnosticLevel;
     allowedUntypedLibraries: string[];
 }
 
@@ -560,6 +561,7 @@ export function getDiagLevelDiagnosticRules() {
         DiagnosticRule.reportIncompatibleUnannotatedOverride,
         DiagnosticRule.reportInvalidAbstractMethod,
         DiagnosticRule.reportSelfClsDefault,
+        DiagnosticRule.reportUnsolvedTypeVar,
     ];
 }
 
@@ -698,6 +700,7 @@ export function getOffDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 
@@ -818,6 +821,7 @@ export function getBasicDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 
@@ -938,6 +942,7 @@ export function getStandardDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 
@@ -1057,6 +1062,7 @@ export const getRecommendedDiagnosticRuleSet = (): DiagnosticRuleSet => ({
     reportIncompatibleUnannotatedOverride: 'none', // TODO: change to error when we're confident there's no performance issues with this rule
     reportInvalidAbstractMethod: 'warning',
     reportSelfClsDefault: 'warning',
+    reportUnsolvedTypeVar: 'error',
     allowedUntypedLibraries: [],
 });
 
@@ -1173,6 +1179,7 @@ export const getAllDiagnosticRuleSet = (): DiagnosticRuleSet => ({
     reportIncompatibleUnannotatedOverride: 'error',
     reportInvalidAbstractMethod: 'error',
     reportSelfClsDefault: 'error',
+    reportUnsolvedTypeVar: 'error',
     allowedUntypedLibraries: [],
 });
 
@@ -1290,6 +1297,7 @@ export function getStrictDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 

packages/pyright-internal/src/common/diagnosticRules.ts

@@ -121,4 +121,5 @@ export enum DiagnosticRule {
     reportIncompatibleUnannotatedOverride = 'reportIncompatibleUnannotatedOverride',
     reportInvalidAbstractMethod = 'reportInvalidAbstractMethod',
     reportSelfClsDefault = 'reportSelfClsDefault',
+    reportUnsolvedTypeVar = 'reportUnsolvedTypeVar',
 }

packages/pyright-internal/src/tests/samples/typeVarUnsolved1.py

@@ -1,5 +1,7 @@
 # this sample tests the detection of unsolved type variables in function calls
 
+from typing import Callable
+
 def func1[T]() -> T: ...
 
 
@@ -53,3 +55,15 @@ def create_from(x: T) -> "MyClass[T]": ...
 
 # ok: T is explicit
 i = MyClass[int]()
+
+def deco[T]() -> Callable[[Callable[[], T]], Callable[[], T]]: ...
+
+# ok: T is None
+@deco()
+def func6():
+    pass
+
+deco()(lambda: None)
+
+# OK: T is inferred from argument
+j: int = func2(func1())

packages/pyright-internal/src/tests/typeEvaluator5.test.ts

@@ -12,6 +12,7 @@ import { ConfigOptions } from '../common/configOptions';
 import { pythonVersion3_11, pythonVersion3_12, pythonVersion3_13 } from '../common/pythonVersion';
 import { Uri } from '../common/uri/uri';
 import * as TestUtils from './testUtils';
+import { DiagnosticRule } from '../common/diagnosticRules';
 
 test('TypeParams1', () => {
     const configOptions = new ConfigOptions(Uri.empty());
@@ -202,12 +203,21 @@ test('TypeVarUnsolved1', () => {
     const configOptions = new ConfigOptions(Uri.empty());
     configOptions.diagnosticRuleSet.reportInvalidTypeVarUse = 'none';
     configOptions.diagnosticRuleSet.reportUnusedParameter = 'none';
+    configOptions.diagnosticRuleSet.reportUnsolvedTypeVar = 'error';
 
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typeVarUnsolved1.py'], configOptions);
     TestUtils.validateResultsButBased(analysisResults, {
         errors: [
-            { line: 19, message: 'Type variable "T" has no solution; consider providing it explicitly' },
-            { line: 25, message: 'Type variable "U" has no solution; consider providing it explicitly' },
+            {
+                line: 21,
+                code: DiagnosticRule.reportUnsolvedTypeVar,
+                message: 'Type variable "T" has no solution; consider providing it explicitly',
+            },
+            {
+                line: 27,
+                code: DiagnosticRule.reportUnsolvedTypeVar,
+                message: 'Type variable "U" has no solution; consider providing it explicitly',
+            },
         ],
     });
 });