Repository: astral-sh/ruff
File: crates/ty_python_semantic/src/types/narrow.rs (Rust)

Code before:
        let mut constraints = NarrowingConstraints::default();

        // Narrow tagged unions of `TypedDict`s with `Literal` keys, for example:
        //
        //     class Foo(TypedDict):
        //         tag: Literal["foo"]
        //     class Bar(TypedDict):
        //         tag: Literal["bar"]
        //     def _(union: Foo | Bar):
        //         if union["tag"] == "foo":
        //             reveal_type(union)  # Foo
        //
        // Importantly, `my_typeddict_union["tag"]` isn't the place we're going to constraint.
        // Instead, we're going to constrain `my_typeddict_union` itself.
        if ops.len() == 1
            && ops[0] == ast::CmpOp::Eq
            && let ast::Expr::Subscript(subscript) = &**left
            && let lhs_value_type = inference.expression_type(&*subscript.value)
            // Checking for `TypedDict`s up front isn't strictly necessary, since the iterator
            // below will yield nothing if it doesn't find any, but we want to do as little work as
            // possible in the common case.
            && is_typeddict_or_union_with_typeddicts(lhs_value_type, self.db)
            && let Some(subscript_place_expr) = place_expr(&subscript.value)
            && let Some(key_literal) = inference
                .expression_type(&*subscript.slice)
                .as_string_literal()
        {
            let field_name = Name::from(key_literal.value(self.db));
            let rhs_type = inference.expression_type(&comparators[0]);
            let mut intersection = IntersectionBuilder::new(self.db);
            // This iterator handles individual `TypedDict`, unions, intersections (the positive
            // members), and unions of intersections.
            for typed_dict_type in all_typeddicts_within_type_iter(lhs_value_type, self.db) {
                if let Some(field) = typed_dict_type.items(self.db).get(&field_name) {
                    let known_equality_result = match (field.declared_ty, rhs_type) {
                        (Type::StringLiteral(lhs), Type::StringLiteral(rhs)) => Some(lhs == rhs),
                        (Type::IntLiteral(lhs), Type::IntLiteral(rhs)) => Some(lhs == rhs),
                        // It's unlikely that the user will mix int and string literals in the same
                        // union, but go ahead and handle it.
                        (Type::StringLiteral(_), Type::IntLiteral(_))
                        | (Type::IntLiteral(_), Type::StringLiteral(_)) => Some(false),
                        _ => None,
                    };
                    if let Some(equality) = known_equality_result
                        && equality != is_positive
                    {
                        // We could synthesize a `TypedDict` with just this one specific field, but
                        // using the caller's own named types makes the resulting intersections
                        // easier to read, in the cases where they don't simplify out.
                        intersection = intersection.add_negative(Type::TypedDict(typed_dict_type));
                    }

Review comment (suggestion):
```suggestion
            && let Type::StringLiteral(key_literal) = inference
                .expression_type(&*subscript.slice)
```

Code after:
            // For example, the negation of  `x is 1 is y is 2`, would be `(x is not 1) or (y is not 1) or (y is not 2)`
            // and that requires cross-symbol constraints, which we don't support yet.
            return None;
        }

        let inference = infer_expression_types(self.db, expression, TypeContext::default());

        let comparator_tuples = std::iter::once(&**left)
            .chain(comparators)
            .tuple_windows::<(&ruff_python_ast::Expr, &ruff_python_ast::Expr)>();
        let mut constraints = NarrowingConstraints::default();

        // Narrow tagged unions of `TypedDict`s with `Literal` keys, for example:
        //
        //     class Foo(TypedDict):
        //         tag: Literal["foo"]
        //     class Bar(TypedDict):
        //         tag: Literal["bar"]
        //     def _(union: Foo | Bar):
        //         if union["tag"] == "foo":
        //             reveal_type(union)  # Foo
        //
        // Importantly, `my_typeddict_union["tag"]` isn't the place we're going to constraint.
        // Instead, we're going to constrain `my_typeddict_union` itself.
        if matches!(&**ops, [ast::CmpOp::Eq | ast::CmpOp::NotEq])
            && let ast::Expr::Subscript(subscript) = &**left
            && let lhs_value_type = inference.expression_type(&*subscript.value)
            // Checking for `TypedDict`s up front isn't strictly necessary, since the intersection
            // we're going to build is compatible with non-`TypedDict` types, but we don't want to
            // do the work to build it and intersect it (or for that matter, let the user see it)
            // in the common case where there are no `TypedDict`s.
            && is_typeddict_or_union_with_typeddicts(self.db, lhs_value_type)
            && let Some(subscript_place_expr) = place_expr(&subscript.value)
            && let Type::StringLiteral(key_literal) = inference.expression_type(&*subscript.slice)
            && let rhs_type = inference.expression_type(&comparators[0])
            && is_supported_typeddict_tag_literal(rhs_type)
        {
            // If we have an equality constraint (either `==` on the `if` side, or `!=` on the
            // `else` side), we have to be careful. If all the matching fields in all the
            // `TypedDict`s here have literal types, then yes, equality is as good as a type check.
            // However, if any of them are e.g. `int` or `str` or some random class, then we can't
            // narrow their type at all, because subclasses of those types can implement `__eq__`
            // in any perverse way they like. On the other hand, if this is an *inequality*
            // constraint, then we can go ahead and assert "you can't be this exact literal type"
            // without worrying about what other types might be present.
            let constrain_with_equality = is_positive == (ops[0] == ast::CmpOp::Eq);
            if !constrain_with_equality
                || all_matching_typeddict_fields_have_literal_types(
                    self.db,
                    lhs_value_type,
                    key_literal.value(self.db),