report error for unsolved type variables in function calls

KotlinIsland · KotlinIsland · commit 09ecbcc84733 · 2026-03-05T16:15:54.000+10:00
diff --git a/.basedpyright/baseline.json b/.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": {
diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
@@ -12607,6 +12607,50 @@ export function createTypeEvaluator(
             specializedInitSelfType = solveAndApplyConstraints(specializedInitSelfType, constraints);
         }
 
+        // 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
+                if (typeParam.shared.isDefaultExplicit) {
+                    continue;
+                }
+
+                // skip ParamSpecs and TypeVarTuples for now - they have different semantics
+                if (isParamSpec(typeParam) || isTypeVarTuple(typeParam)) {
+                    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 (!solvedType) {
+                    addDiagnostic(
+                        DiagnosticRule.reportUnsolvedTypeVar,
+                        LocMessage.typeVarUnsolved().format({
+                            name: typeParam.shared.name,
+                        }),
+                        errorNode
+                    );
+                }
+            }
+        }
+
         matchResults.argumentMatchScore = argumentMatchScore;
 
         return {
diff --git a/packages/pyright-internal/src/common/configOptions.ts b/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: [],
     };
 
diff --git a/packages/pyright-internal/src/common/diagnosticRules.ts b/packages/pyright-internal/src/common/diagnosticRules.ts
@@ -121,4 +121,5 @@ export enum DiagnosticRule {
     reportIncompatibleUnannotatedOverride = 'reportIncompatibleUnannotatedOverride',
     reportInvalidAbstractMethod = 'reportInvalidAbstractMethod',
     reportSelfClsDefault = 'reportSelfClsDefault',
+    reportUnsolvedTypeVar = 'reportUnsolvedTypeVar',
 }
diff --git a/packages/pyright-internal/src/localization/localize.ts b/packages/pyright-internal/src/localization/localize.ts
@@ -1113,6 +1113,8 @@ export namespace Localizer {
             new ParameterizedString<{ type: string; name: string }>(
                 getRawString('Diagnostic.typeVarAssignmentMismatch')
             );
+        export const typeVarUnsolved = () =>
+            new ParameterizedString<{ name: string }>(getRawString('Diagnostic.typeVarUnsolved'));
         export const typeVarBoundAndConstrained = () => getRawString('Diagnostic.typeVarBoundAndConstrained');
         export const typeVarBoundGeneric = () => getRawString('Diagnostic.typeVarBoundGeneric');
         export const typeVarConstraintGeneric = () => getRawString('Diagnostic.typeVarConstraintGeneric');
diff --git a/packages/pyright-internal/src/localization/package.nls.en-us.json b/packages/pyright-internal/src/localization/package.nls.en-us.json
@@ -1436,6 +1436,9 @@
             "comment": "{Locked='TypeVar'}"
         },
         "typeVarAssignmentMismatch": "Type \"{type}\" cannot be assigned to type variable \"{name}\"",
+        "typeVarUnsolved": {
+            "message": "Type variable \"{name}\" has no solution; consider providing it explicitly"
+        },
         "typeVarBoundAndConstrained": {
             "message": "TypeVar cannot be both bound and constrained",
             "comment": "{Locked='TypeVar'}"
diff --git a/packages/pyright-internal/src/tests/samples/typeVarUnsolved1.py b/packages/pyright-internal/src/tests/samples/typeVarUnsolved1.py
@@ -0,0 +1,69 @@
+# this sample tests the detection of unsolved type variables in function calls
+
+from typing import Callable
+
+def func1[T]() -> T: ...
+
+
+def func2[T](x: T) -> T:
+    return x
+
+
+def func3[T, U](x: T) -> U: ...
+
+
+def func4[T = int]() -> T: ...
+
+
+def func5[T, U = str](x: T) -> U: ...
+
+
+# Error: T cannot be inferred
+a = func1()
+
+# OK: T is inferred from argument
+b = func2(1)
+
+# Error: U cannot be inferred (T is fine)
+c = func3(1)
+
+# OK: T has a default value
+d = func4()
+
+# OK: T is inferred, U has a default value
+e = func5(1)
+
+
+# test with explicit type arguments
+f: int = func1()
+
+
+# test class with unsolved type var
+class MyClass[T]:
+    @staticmethod
+    def create() -> "MyClass[T]": ...
+
+    @staticmethod
+    def create_from(x: T) -> "MyClass[T]": ...
+
+
+# Error: T cannot be inferred
+g = MyClass.create()
+
+# OK: T is inferred from argument
+h = MyClass.create_from(42)
+
+# 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())
diff --git a/packages/pyright-internal/src/tests/typeEvaluator5.test.ts b/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());
@@ -198,6 +199,29 @@ test('TypeVarDefault1', () => {
     TestUtils.validateResults(analysisResults, 14);
 });
 
+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: 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',
+            },
+        ],
+    });
+});
+
 test('TypeVarDefault2', () => {
     const configOptions = new ConfigOptions(Uri.empty());
     configOptions.defaultPythonVersion = pythonVersion3_13;
diff --git a/packages/vscode-pyright/package.json b/packages/vscode-pyright/package.json
@@ -439,6 +439,23 @@
                                 false
                             ]
                         },
+                        "reportUnsolvedTypeVar": {
+                            "type": [
+                                "string",
+                                "boolean"
+                            ],
+                            "description": "Diagnostics for a call-site with an unsolved type variable.",
+                            "default": "none",
+                            "enum": [
+                                "none",
+                                "hint",
+                                "information",
+                                "warning",
+                                "error",
+                                true,
+                                false
+                            ]
+                        },
                         "reportDuplicateImport": {
                             "type": [
                                 "string",
diff --git a/packages/vscode-pyright/schemas/pyrightconfig.schema.json b/packages/vscode-pyright/schemas/pyrightconfig.schema.json
@@ -170,6 +170,11 @@
       "title": "Controls reporting of local variables that are not accessed",
       "default": "hint"
     },
+    "reportUnsolvedTypeVar": {
+      "$ref": "#/definitions/diagnostic",
+      "title": "Controls reporting of function calls with unresolved type variables",
+      "default": "none"
+    },
     "reportDuplicateImport": {
       "$ref": "#/definitions/diagnostic",
       "title": "Controls reporting of symbols or modules that are imported more than once",
@@ -735,6 +740,9 @@
     "reportUnusedVariable": {
       "$ref": "#/definitions/reportUnusedVariable"
     },
+    "reportUnsolvedTypeVar": {
+      "$ref": "#/definitions/reportUnsolvedTypeVar"
+    },
     "reportDuplicateImport": {
       "$ref": "#/definitions/reportDuplicateImport"
     },
@@ -1100,6 +1108,9 @@
           "reportUnusedVariable": {
             "$ref": "#/definitions/reportUnusedVariable"
           },
+          "reportUnsolvedTypeVar": {
+            "$ref": "#/definitions/reportUnsolvedTypeVar"
+          },
           "reportDuplicateImport": {
             "$ref": "#/definitions/reportDuplicateImport"
           },

Original file line number	Diff line number	Diff line change
`@@ -121,4 +121,5 @@ export enum DiagnosticRule {`
`121`	`121`	`reportIncompatibleUnannotatedOverride = 'reportIncompatibleUnannotatedOverride',`
`122`	`122`	`reportInvalidAbstractMethod = 'reportInvalidAbstractMethod',`
`123`	`123`	`reportSelfClsDefault = 'reportSelfClsDefault',`
	`124`	`+ reportUnsolvedTypeVar = 'reportUnsolvedTypeVar',`
`124`	`125`	`}`