report error for unsolved type variables in function calls

.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/constructors.ts

@@ -15,6 +15,7 @@
 import { appendArray } from '../common/collectionUtils';
 import { DiagnosticAddendum } from '../common/diagnostic';
 import { DiagnosticRule } from '../common/diagnosticRules';
+import { LocMessage } from '../localization/localize';
 import { ExpressionNode, ParamCategory } from '../parser/parseNodes';
 import { ConstraintSolution } from './constraintSolution';
 import { addConstraintsForExpectedType } from './constraintSolver';
@@ -40,7 +41,9 @@ import {
     isInstantiableClass,
     isNever,
     isOverloaded,
+    isParamSpec,
     isTypeVar,
+    isTypeVarTuple,
     isUnknown,
 } from './types';
 import {
@@ -478,6 +481,10 @@ function validateNewMethod(
         newReturnType = applyExpectedTypeForConstructor(evaluator, type, inferenceContext, constraints);
     }
 
+    if (!argumentErrors && !isTypeIncomplete && !useSpeculativeModeForArgs) {
+        reportUnsolvedClassTypeParams(evaluator, type, constraints, errorNode);
+    }
+
     return { argumentErrors, returnType: newReturnType, isTypeIncomplete, overloadsUsedForCall };
 }
 
@@ -531,8 +538,11 @@ function validateInitMethod(
 
     if (callResult.argumentErrors) {
         argumentErrors = true;
-    } else if (callResult.overloadsUsedForCall) {
-        overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+    } else {
+        if (callResult.overloadsUsedForCall) {
+            overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+        }
+        reportUnsolvedClassTypeParams(evaluator, adjustedClassType, constraints, errorNode);
     }
 
     return { argumentErrors, returnType, isTypeIncomplete, overloadsUsedForCall };
@@ -640,6 +650,34 @@ function applyExpectedSubtypeForConstructor(
     return specializedType;
 }
 
+// Reports errors for class-level type parameters that have no solution in the constraints.
+function reportUnsolvedClassTypeParams(
+    evaluator: TypeEvaluator,
+    classType: ClassType,
+    constraints: ConstraintTracker,
+    errorNode: ExpressionNode
+): void {
+    if (classType.shared.typeParams.length === 0 || classType.priv.typeArgs) {
+        return;
+    }
+    const constraintSet = constraints.getMainConstraintSet();
+    for (const typeParam of classType.shared.typeParams) {
+        if (typeParam.shared.isDefaultExplicit) {
+            continue;
+        }
+        if (isParamSpec(typeParam) || isTypeVarTuple(typeParam)) {
+            continue;
+        }
+        if (!constraintSet.getTypeVar(typeParam)?.lowerBound) {
+            evaluator.addDiagnostic(
+                DiagnosticRule.reportUnsolvedTypeVar,
+                LocMessage.typeVarUnsolved().format({ name: typeParam.shared.name }),
+                errorNode
+            );
+        }
+    }
+}
+
 // Handles the case where a constructor is a generic type and the type
 // arguments are not specified but can be provided by the expected type.
 function applyExpectedTypeForConstructor(

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

@@ -12617,6 +12617,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 {
@@ -15077,6 +15121,17 @@ export function createTypeEvaluator(
             }
         } else {
             isEmptyContainer = true;
+
+            // Report unsolved type variable for empty containers without expected type
+            if (!hasExpectedType) {
+                const diag = new DiagnosticAddendum();
+                diag.addMessage(LocAddendum.typeVarUnsolvedCollectionHint().format({ className: builtInClassName }));
+                addDiagnostic(
+                    DiagnosticRule.reportUnsolvedTypeVar,
+                    LocMessage.typeVarUnsolved().format({ name: 'T' }) + diag.getString(),
+                    node
+                );
+            }
         }
 
         const listOrSetClass = getBuiltInType(node, builtInClassName);

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

@@ -430,6 +430,7 @@ export interface DiagnosticRuleSet {
     reportIncompatibleUnannotatedOverride: DiagnosticLevel;
     reportInvalidAbstractMethod: DiagnosticLevel;
     reportSelfClsDefault: DiagnosticLevel;
+    reportUnsolvedTypeVar: DiagnosticLevel;
     allowedUntypedLibraries: string[];
 }
 
@@ -564,6 +565,7 @@ export function getDiagLevelDiagnosticRules() {
         DiagnosticRule.reportIncompatibleUnannotatedOverride,
         DiagnosticRule.reportInvalidAbstractMethod,
         DiagnosticRule.reportSelfClsDefault,
+        DiagnosticRule.reportUnsolvedTypeVar,
     ];
 }
 
@@ -703,6 +705,7 @@ export function getOffDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 
@@ -824,6 +827,7 @@ export function getBasicDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 
@@ -945,6 +949,7 @@ export function getStandardDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 
@@ -1065,6 +1070,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: [],
 });
 
@@ -1182,6 +1188,7 @@ export const getAllDiagnosticRuleSet = (): DiagnosticRuleSet => ({
     reportIncompatibleUnannotatedOverride: 'error',
     reportInvalidAbstractMethod: 'error',
     reportSelfClsDefault: 'error',
+    reportUnsolvedTypeVar: 'error',
     allowedUntypedLibraries: [],
 });
 
@@ -1300,6 +1307,7 @@ export function getStrictDiagnosticRuleSet(): DiagnosticRuleSet {
         reportIncompatibleUnannotatedOverride: 'none',
         reportInvalidAbstractMethod: 'none',
         reportSelfClsDefault: 'none',
+        reportUnsolvedTypeVar: 'none',
         allowedUntypedLibraries: [],
     };
 

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

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

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');
@@ -1670,6 +1672,10 @@ export namespace Localizer {
             new ParameterizedString<{ exceptionType: string; parentType: string }>(
                 getRawString('DiagnosticAddendum.unreachableExcept')
             );
+        export const typeVarUnsolvedCollectionHint = () =>
+            new ParameterizedString<{ className: string }>(
+                getRawString('DiagnosticAddendum.typeVarUnsolvedCollectionHint')
+            );
         export const useDictInstead = () => getRawString('DiagnosticAddendum.useDictInstead');
         export const useListInstead = () => getRawString('DiagnosticAddendum.useListInstead');
         export const useTupleInstead = () => getRawString('DiagnosticAddendum.useTupleInstead');

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'}"
@@ -2185,6 +2188,10 @@
             "message": "Use tuple[T1, ..., Tn] to indicate a tuple type or T1 | T2 to indicate a union type",
             "comment": "{Locked='tuple[T1, ..., Tn]','tuple','T1 | T2','union'}"
         },
+        "typeVarUnsolvedCollectionHint": {
+            "message": "e.g. \"{className}[<type>]()\"",
+            "comment": "{Locked='{className}[<type>]()'}"
+        },
         "useTypeInstead": {
             "message": "Use type[T] instead",
             "comment": "{Locked='type[T]'}"

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

@@ -0,0 +1,72 @@
+# this sample tests the detection of unsolved type variables in function calls
+
+from typing import Any, 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)  # pyright: ignore[reportUnsolvedTypeVar]
+
+# 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()
+
+class MyClass[T]: ...
+
+# ok: T is explicit
+i = MyClass[int]()
+
+# error: can't infer class type from constructor
+i = MyClass()  # pyright: ignore[reportUnsolvedTypeVar]
+
+class Default[T=Any]: ...
+
+# ok: T is explicit
+i = Default[int]()
+
+# ok: uses default
+i = Default()
+
+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())
+
+# error
+k = []
+
+# no error
+l: list[int] = []