Improved handling of constrained TypeVars when used with unary operators. This addresses #7874. (#7900)

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

@@ -1031,7 +1031,27 @@ export function getTypeOfUnaryOperation(
                 type = exprType;
             } else {
                 const magicMethodName = unaryOperatorMap[node.operator];
-                type = evaluator.getTypeOfMagicMethodCall(exprType, magicMethodName, [], node, inferenceContext);
+                let isResultValid = true;
+
+                type = evaluator.mapSubtypesExpandTypeVars(exprType, /* options */ undefined, (subtypeExpanded) => {
+                    const result = evaluator.getTypeOfMagicMethodCall(
+                        subtypeExpanded,
+                        magicMethodName,
+                        [],
+                        node,
+                        inferenceContext
+                    );
+
+                    if (!result) {
+                        isResultValid = false;
+                    }
+
+                    return result;
+                });
+
+                if (!isResultValid) {
+                    type = undefined;
+                }
             }
 
             if (!type) {

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

@@ -0,0 +1,14 @@
+# This sample tests the handling of operators when used with constrained
+# type variables.
+
+from typing import Generic, TypeVar
+
+T = TypeVar("T", int, float)
+
+
+class A(Generic[T]):
+    def __init__(self, x: T):
+        self.x: T = x
+
+    def __neg__(self) -> "A[T]":
+        return A[T](x=-self.x)

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

@@ -383,6 +383,12 @@ test('Operator11', () => {
     TestUtils.validateResults(analysisResults, 0);
 });
 
+test('Operator12', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator12.py']);
+
+    TestUtils.validateResults(analysisResults, 0);
+});
+
 test('Optional1', () => {
     const configOptions = new ConfigOptions(Uri.empty());