Do not treat Any in type variable bounds as hints

Summary:
Fixes #3265.

___

landed-with-radar-review

Differential Revision: D128999763

fbshipit-source-id: 06485aed9ac0e503c3e305c7ba457358b0c8b12d

Author: rchen152

pyrefly/lib/alt/expr.rs

@@ -100,7 +100,6 @@ use crate::alt::shape_extension::is_int_tuple_bound;
 use crate::alt::solve::TypeFormContext;
 use crate::alt::solve::UntypeContext;
 use crate::alt::unwrap::HintRef;
-use crate::alt::unwrap::ListElementHint;
 use crate::binding::binding::Binding;
 use crate::binding::binding::BindingClass;
 use crate::binding::binding::Key;
@@ -1261,23 +1260,14 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                 hint,
                 |hint| self.decompose_list(hint),
                 |elem_hint, hint| {
-                    let (elem_hint, partial_fallback) = elem_hint
-                        .map(ListElementHint::into_parts)
-                        .unwrap_or_default();
                     self.ifs_infer(&x.generators, errors);
                     let elem_ty = self.expr_infer_with_hint_promote(
                         &x.elt,
                         HintRef::with_ty_opt(hint, elem_hint.as_ref()),
                         errors,
                         HintCoercion::BestEffort,
                     );
-                    let ty = self.heap.mk_class_type(self.stdlib.list(elem_ty));
-                    if let Some(partial_fallback) = partial_fallback {
-                        self.solver()
-                            .replace_unresolved_partials(ty, &partial_fallback)
-                    } else {
-                        ty
-                    }
+                    self.heap.mk_class_type(self.stdlib.list(elem_ty))
                 },
             ),
             Expr::SetComp(x) => self.infer_with_decomposed_hint(
@@ -3521,37 +3511,25 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
     fn list_literal_infer(
         &self,
         list: &ExprList,
-        elt_hint: Option<ListElementHint>,
+        elt_hint: Option<Type>,
         hint: Option<HintRef>,
         errors: &ErrorCollector,
     ) -> Type {
         if list.is_empty() {
-            let elem_ty = match elt_hint {
-                Some(ListElementHint::Hint(elem_hint)) => elem_hint,
-                Some(ListElementHint::UninformativeAny(_)) | None => self
-                    .solver()
+            let elem_ty = elt_hint.unwrap_or_else(|| {
+                self.solver()
                     .fresh_partial_contained(self.uniques, list.range)
-                    .to_type(self.heap),
-            };
+                    .to_type(self.heap)
+            });
             self.heap.mk_class_type(self.stdlib.list(elem_ty))
         } else {
-            let (elt_hint, partial_fallback) = elt_hint
-                .map(ListElementHint::into_parts)
-                .unwrap_or_default();
             let elem_tys = self.elts_infer(
                 &list.elts,
                 HintRef::with_ty_opt(hint, elt_hint.as_ref()),
                 errors,
             );
-            let ty = self
-                .heap
-                .mk_class_type(self.stdlib.list(self.unions(elem_tys)));
-            if let Some(partial_fallback) = partial_fallback {
-                self.solver()
-                    .replace_unresolved_partials(ty, &partial_fallback)
-            } else {
-                ty
-            }
+            self.heap
+                .mk_class_type(self.stdlib.list(self.unions(elem_tys)))
         }
     }
 

pyrefly/lib/alt/unwrap.rs

@@ -27,26 +27,6 @@ use crate::types::types::Var;
 /// individually, as doing so would be prohibitively expensive.
 pub const MAX_HINT_WIDTH: usize = 32;
 
-/// A contextual element hint for list literals and comprehensions.
-pub(crate) enum ListElementHint {
-    /// A hint that should be applied while inferring the element.
-    Hint(Type),
-    /// An `Any` hint that is ignored for inference but retained as a fallback.
-    ///
-    /// The contained type is always `Any`, preserving its original `AnyStyle`.
-    UninformativeAny(Type),
-}
-
-impl ListElementHint {
-    /// Split the hint into an inference hint and a fallback.
-    pub(crate) fn into_parts(self) -> (Option<Type>, Option<Type>) {
-        match self {
-            Self::Hint(ty) => (Some(ty), None),
-            Self::UninformativeAny(ty) => (None, Some(ty)),
-        }
-    }
-}
-
 // The error collector is None for a "soft" type hint, where we try to
 // match an expression against a hint, but fall back to the inferred type
 // without any errors if the hint is incompatible.
@@ -367,27 +347,13 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         }
     }
 
-    pub(crate) fn decompose_list(&self, hint: &Type) -> Option<ListElementHint> {
+    pub fn decompose_list(&self, hint: &Type) -> Option<Type> {
         let elem = self.fresh_var();
         let list_type = self
             .heap
             .mk_class_type(self.stdlib.list(elem.to_type(self.heap)));
         if self.is_subset_eq(&list_type, hint) {
-            match self.resolve_var_opt(hint, elem) {
-                Some(elem_hint)
-                    if elem_hint.is_any()
-                        && hint
-                            .collect_maybe_placeholder_vars()
-                            .into_iter()
-                            .any(|var| self.solver().var_is_quantified(var)) =>
-                {
-                    // An `Any` element hint obtained while the container hint still has an unsolved
-                    // generic variable carries no information about the literal's elements.
-                    Some(ListElementHint::UninformativeAny(elem_hint))
-                }
-                Some(elem_hint) => Some(ListElementHint::Hint(elem_hint)),
-                None => None,
-            }
+            self.resolve_var_opt(hint, elem)
         } else {
             None
         }
@@ -544,26 +510,41 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         }
     }
 
-    pub fn decompose_hint<'b, D>(
+    pub fn decompose_hint<D>(
         &self,
-        hint: HintRef<'_, 'b>,
-        decompose: impl Fn(&'b Type) -> Option<D>,
+        hint: HintRef,
+        decompose: impl Fn(&Type) -> Option<D>,
     ) -> Vec<D> {
         hint.types()
             .iter()
             .filter_map(|hint| self.decompose_one_hint(hint, &decompose))
             .collect()
     }
 
-    fn decompose_one_hint<'b, D>(
+    fn decompose_one_hint<D>(
         &self,
-        hint: &'b Type,
-        decompose: impl FnOnce(&'b Type) -> Option<D>,
+        hint: &Type,
+        decompose: impl FnOnce(&Type) -> Option<D>,
     ) -> Option<D> {
+        let hint_vars = hint.collect_maybe_placeholder_vars();
         // Decomposing a hint should not have any side effects.
-        let snapshot = self
-            .solver()
-            .snapshot_exact_vars(&hint.collect_maybe_placeholder_vars());
+        let snapshot = self.solver().snapshot_exact_vars(&hint_vars);
+        // An `Any` in an unconstrained type variable's bound supplies no contextual information.
+        // Fresh vars in those positions preserve the bound's structural constraints.
+        for var in hint_vars {
+            if let Some(bound) = self.solver().unconstrained_typevar_bound(var) {
+                let mut transformed = false;
+                let bound = bound.transform(&mut |ty| {
+                    if ty.is_any() {
+                        *ty = self.fresh_var().to_type(self.heap);
+                        transformed = true;
+                    }
+                });
+                if transformed {
+                    self.solver().set_typevar_bound(var, bound);
+                }
+            }
+        }
         let ret = decompose(hint);
         self.solver().restore_vars(snapshot);
         ret

pyrefly/lib/solver/solver.rs

@@ -795,30 +795,6 @@ impl Solver {
         )
     }
 
-    /// Replace unresolved empty-container element types with `fallback` in a copy of `ty`.
-    pub(crate) fn replace_unresolved_partials(&self, mut ty: Type, fallback: &Type) -> Type {
-        self.expand_mut(&mut ty);
-        let partials: SmallSet<_> = {
-            let variables = self.variables.lock();
-            ty.collect_maybe_placeholder_vars()
-                .into_iter()
-                .filter(|var| {
-                    matches!(
-                        &*variables.get(*var),
-                        Variable::PartialQuantified(_) | Variable::PartialContained(_)
-                    )
-                })
-                .collect()
-        };
-        ty.transform_mut(&mut |ty| {
-            if matches!(ty, Type::Var(var) if partials.contains(var)) {
-                *ty = fallback.clone();
-            }
-        });
-        self.simplify_mut(&mut ty);
-        ty
-    }
-
     /// Returns true if the given type is a Var that points to a partial variable.
     pub fn is_partial(&self, ty: &Type) -> bool {
         if let Type::Var(v) = ty {
@@ -835,6 +811,33 @@ impl Solver {
         matches!(&*variables.get(var), Variable::Quantified { .. })
     }
 
+    /// The bound of the type variable that `var` stands for, if inference has not yet given it a
+    /// solution or bounds of its own.
+    pub(crate) fn unconstrained_typevar_bound(&self, var: Var) -> Option<Type> {
+        let variables = self.variables.lock();
+        match &*variables.get(var) {
+            Variable::Quantified { quantified, bounds } if bounds.is_empty() => {
+                match quantified.restriction() {
+                    Restriction::Bound(bound) => Some(bound.clone()),
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+
+    /// Replace a type variable's declared bound during speculative hint decomposition.
+    pub(crate) fn set_typevar_bound(&self, var: Var, bound: Type) {
+        let variables = self.variables.lock();
+        let mut variable = variables.get_mut(var);
+        let Variable::Quantified { quantified, .. } = &mut *variable else {
+            unreachable!("only an unconstrained type variable has its bound replaced")
+        };
+        *quantified = quantified
+            .clone()
+            .with_restriction(Restriction::Bound(bound));
+    }
+
     /// The vars an argument could fill in that are still waiting for an answer.
     pub(crate) fn unsolved_argument_vars(&self, argument: &MatchedArgument) -> Vec<Var> {
         let variables = self.variables.lock();

pyrefly/lib/test/calls.rs

@@ -1021,14 +1021,13 @@ reduce(max, [1,2])
 // https://github.com/facebook/pyrefly/issues/3265
 // All of these iterators should have element type int without diagnostics.
 testcase!(
-    bug = "iter loses element types for set and dict literals",
     test_iter_container_literal,
     r#"
 from typing import Iterator, assert_type
 
 assert_type(iter([0]), Iterator[int])
-assert_type(iter({0}), Iterator[int])  # E: assert_type(Iterator[Any], Iterator[int]) failed
-assert_type(iter({0: 0}), Iterator[int])  # E: assert_type(Iterator[Any], Iterator[int]) failed
+assert_type(iter({0}), Iterator[int])
+assert_type(iter({0: 0}), Iterator[int])
 assert_type(iter([x for x in [0]]), Iterator[int])
 assert_type(iter({x for x in [0]}), Iterator[int])
 assert_type(iter({x: x for x in [0]}), Iterator[int])

pyrefly/lib/test/contextual.rs

@@ -236,46 +236,92 @@ assert_type(keep([]), list[Any])
     "#,
 );
 
+testcase!(
+    test_any_bounded_typevar_preserves_structure,
+    r#"
+from typing import Any, assert_type, overload
+
+class Array[S, D]: ...
+
+@overload
+def stack[S: tuple[int, int, *tuple[Any, ...]], D](
+    xs: list[Array[S, D]],
+) -> Array[S, D]: ...
+@overload
+def stack[D](xs: list[Array[tuple[int], D]]) -> Array[tuple[int, int], D]: ...
+def stack(xs):
+    return Array()
+
+a: Array[tuple[int], int] = Array()
+assert_type(stack([a, a]), Array[tuple[int, int], int])
+b: Array[tuple[int, int, int], str] = Array()
+assert_type(stack([b, b]), Array[tuple[int, int, int], str])
+
+def keep[T: dict[float, Any]](x: T) -> T: ...
+assert_type(keep({0: "a"}), dict[float, str])
+    "#,
+);
+
+testcase!(
+    test_any_bounded_typevar_preserves_subclass,
+    r#"
+from typing import Any, assert_type
+
+class Scalar[T]:
+    def item(self) -> T: ...
+class Float32(Scalar[float]): ...
+class Array[S, D]:
+    def scalar(self) -> D: ...
+
+def stack[T: Scalar[Any]](
+    xs: list[T | Array[tuple[int], T]],
+) -> Array[tuple[int, int], T]: ...
+
+a: Array[tuple[int], Float32] = Array()
+assert_type(stack([a, a]), Array[tuple[int, int], Float32])
+    "#,
+);
+
+// The `Any` in the element bound supplies no hint for a nested empty literal.
 testcase!(
     test_any_bounded_typevar_nested_empty_literal,
     r#"
 from typing import Any, reveal_type
 
 def keep[T: list[Any]](x: T) -> T: ...
 
-reveal_type(keep([[]]))  # E: revealed type: list[list[Any]]
-reveal_type(keep([[], [1]]))  # E: revealed type: list[list[int] | list[Any]]
-reveal_type(keep([[] for _ in [0]]))  # E: revealed type: list[list[Any]]
-reveal_type(keep([set()]))  # E: revealed type: list[set[Any]]
-reveal_type(keep([list()]))  # E: revealed type: list[list[Any]]
-reveal_type(keep([{}]))  # E: revealed type: list[dict[Any, Any]]
+reveal_type(keep([[]]))  # E: revealed type: list[list[@_]]
+reveal_type(keep([[], [1]]))  # E: revealed type: list[list[int] | list[@_]]
+reveal_type(keep([[] for _ in [0]]))  # E: revealed type: list[list[@_]]
+reveal_type(keep([set()]))  # E: revealed type: list[set[@_]]
+reveal_type(keep([list()]))  # E: revealed type: list[list[@_]]
+reveal_type(keep([{}]))  # E: revealed type: list[dict[@_, @_]]
     "#,
 );
 
 // https://github.com/facebook/pyrefly/issues/3265
 // Any in a bound should preserve the concrete element types asserted below.
 testcase!(
-    bug = "Any bounds erase inferred container element types",
     test_any_bounded_typevar_container_hints,
     r#"
 from typing import Any, Iterator, Protocol, assert_type
 
 def keep_set[T: set[Any]](x: T) -> T: ...
 def keep_dict[T: dict[Any, Any]](x: T) -> T: ...
-assert_type(keep_set({0}), set[int])  # E: assert_type(set[Any], set[int]) failed
-assert_type(keep_set({x for x in [0]}), set[int])  # E: assert_type(set[Any], set[int]) failed
-assert_type(keep_dict({0: "a"}), dict[int, str])  # E: assert_type(dict[Any, Any], dict[int, str]) failed
-assert_type(keep_dict({x: str(x) for x in [0]}), dict[int, str])  # E: assert_type(dict[Any, Any], dict[int, str]) failed
+assert_type(keep_set({0}), set[int])
+assert_type(keep_set({x for x in [0]}), set[int])
+assert_type(keep_dict({0: "a"}), dict[int, str])
+assert_type(keep_dict({x: str(x) for x in [0]}), dict[int, str])
 assert_type(keep_dict({}), dict[Any, Any])
-assert_type(keep_dict({0: []}), dict[int, list[Any]])  # E: assert_type(dict[Any, Any], dict[int, list[Any]]) failed
+assert_type(keep_dict({0: []}), dict[int, list[Any]])
 
 class ReturnsIterator[T](Protocol):
     def __iter__(self) -> T: ...
 
 def iterator[I: Iterator[Any]](x: ReturnsIterator[I]) -> I: ...
 assert_type(iterator([0]), Iterator[int])
-assert_type(iterator({0}), Iterator[int])  # E: assert_type(Iterator[Any], Iterator[int]) failed
-assert_type(iterator({0: "a"}), Iterator[int])  # E: assert_type(Iterator[Any], Iterator[int]) failed
+assert_type(iterator({0}), Iterator[int])
+assert_type(iterator({0: "a"}), Iterator[int])
 
 # Concrete bounds and explicit Any annotations still supply contextual types.
 def floats[T: list[float]](x: T) -> T: ...