Fixed bug that led to a false positive error when a TypeVar was bound to StringLiteral and conditionally narrowed. This addresses microsoft/pyright#4857.

Author: msfterictraut

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

@@ -284,6 +284,7 @@ import {
     isTypeAliasPlaceholder,
     isTypeAliasRecursive,
     isTypeVarLimitedToCallable,
+    isTypeVarSame,
     isUnboundedTupleClass,
     isUnionableType,
     isVarianceOfTypeArgumentCompatible,
@@ -1514,7 +1515,13 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 if (ClassType.isBuiltIn(subtype, 'LiteralString')) {
                     // Handle "LiteralString" specially.
                     if (strClassType && isInstantiableClass(strClassType)) {
-                        return ClassType.cloneAsInstance(strClassType);
+                        let strInstance = ClassType.cloneAsInstance(strClassType);
+
+                        if (subtype.condition) {
+                            strInstance = TypeBase.cloneForCondition(strInstance, getTypeCondition(subtype));
+                        }
+
+                        return strInstance;
                     }
                 }
             }
@@ -22690,7 +22697,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
         // Before performing any other checks, see if the dest type is a
         // TypeVar that we are attempting to match.
         if (isTypeVar(destType)) {
-            if (isTypeSame(destType, srcType)) {
+            if (isTypeVarSame(destType, srcType)) {
                 if (destType.scopeId && destTypeVarContext?.hasSolveForScope(destType.scopeId)) {
                     return assignTypeToTypeVar(
                         evaluatorInterface,

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

@@ -215,6 +215,42 @@ export function isIncompleteUnknown(type: Type): boolean {
     return isUnknown(type) && type.isIncomplete;
 }
 
+// Similar to isTypeSame except that type1 is a TypeVar and type2
+// can be either a TypeVar of the same type or a union that includes
+// conditional types associated with that bound TypeVar.
+export function isTypeVarSame(type1: TypeVarType, type2: Type) {
+    if (isTypeSame(type1, type2)) {
+        return true;
+    }
+
+    // If this isn't a bound TypeVar, return false.
+    if (type1.details.isParamSpec || type1.details.isVariadic || !type1.details.boundType) {
+        return false;
+    }
+
+    // If the second type isn't a union, return false.
+    if (!isUnion(type2)) {
+        return false;
+    }
+
+    let isCompatible = true;
+    doForEachSubtype(type2, (subtype) => {
+        if (!isCompatible) {
+            return;
+        }
+
+        if (!isTypeSame(type1, subtype)) {
+            const conditions = getTypeCondition(subtype);
+
+            if (!conditions || !conditions.some((condition) => condition.typeVarName === type1.nameWithScope)) {
+                isCompatible = false;
+            }
+        }
+    });
+
+    return isCompatible;
+}
+
 export function makeInferenceContext(
     expectedType: undefined,
     typeVarContext?: TypeVarContext,

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

@@ -0,0 +1,26 @@
+# This sample tests the case where a LiteralString is used as the bound
+# of a TypeVar.
+
+from typing import Generic, TypeVar, LiteralString
+
+T = TypeVar("T")
+T_LS = TypeVar("T_LS", bound=LiteralString)
+
+
+class ClassA(Generic[T]):
+    def __init__(self, val: T) -> None:
+        ...
+
+
+def func1(x: T) -> ClassA[T]:
+    return ClassA(x)
+
+
+def func2(x: T_LS | None, default: T_LS) -> ClassA[T_LS]:
+    if x is None:
+        x = default
+
+    reveal_type(x, expected_text="T_LS@func2 | LiteralString*")
+    out = func1(x)
+    reveal_type(out, expected_text="ClassA[T_LS@func2 | str*]")
+    return out

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

@@ -1458,6 +1458,12 @@ test('LiteralString2', () => {
     TestUtils.validateResults(analysisResults, 0);
 });
 
+test('LiteralString3', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['literalString3.py']);
+
+    TestUtils.validateResults(analysisResults, 0);
+});
+
 test('ParamInference1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['paramInference1.py']);