fix panic: entered unreachable code: Expected a QuantifiedValue, got @_ #1659 (#1884)

Summary:
Fixes #1659

scoped_type_params no longer asks the solver to resolve each TypeParameter (which caused the recursive Type::Var). It now reads the TypeParameter binding directly, builds the Quantified via the shared helper quantified_from_type_parameter, and takes the active ErrorCollector so diagnostics still flow to the correct sink. Call sites in class tparams, function tparams, and scoped type aliases were updated to pass errors.

Pull Request resolved: #1884

Test Plan: Added a regression test that models class C[T: C] to lock in the crash reported in #1659.

Reviewed By: stroxler

Differential Revision: D89520905

Pulled By: rchen152

fbshipit-source-id: 7b70551fc29214e4c9cfd26d71cd1d150a71f989

Author: asukaminato0721

pyrefly/lib/alt/class/tparams.rs

@@ -40,7 +40,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         scoped_type_params: Option<&TypeParams>,
         errors: &ErrorCollector,
     ) -> Arc<TParams> {
-        let scoped_tparams = self.scoped_type_params(scoped_type_params);
+        let scoped_tparams = self.scoped_type_params(scoped_type_params, errors);
         self.validated_tparams(name.range, scoped_tparams, TParamsSource::Class, errors)
     }
 
@@ -52,7 +52,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         legacy: &[Idx<KeyLegacyTypeParam>],
         errors: &ErrorCollector,
     ) -> Arc<TParams> {
-        let scoped_tparams = self.scoped_type_params(scoped_type_params);
+        let scoped_tparams = self.scoped_type_params(scoped_type_params, errors);
         let legacy_tparams = legacy
             .iter()
             .filter_map(|key| self.get_idx(*key).deref().parameter().cloned())

pyrefly/lib/alt/function.rs

@@ -459,7 +459,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             &mut parent_param_hints,
             errors,
         );
-        let mut tparams = self.scoped_type_params(def.type_params.as_deref());
+        let mut tparams = self.scoped_type_params(def.type_params.as_deref(), errors);
         let legacy_tparams = legacy_tparams
             .iter()
             .filter_map(|key| self.get_idx(*key).deref().parameter().cloned());

pyrefly/lib/alt/solve.rs

@@ -1374,23 +1374,79 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         })
     }
 
-    pub fn scoped_type_params(&self, x: Option<&TypeParams>) -> Vec<TParam> {
+    fn quantified_from_type_parameter(
+        &self,
+        tp: &TypeParameter,
+        errors: &ErrorCollector,
+    ) -> Quantified {
+        let restriction = if let Some(bound) = &tp.bound {
+            let bound_ty = self.expr_untype(bound, TypeFormContext::TypeVarConstraint, errors);
+            Restriction::Bound(bound_ty)
+        } else if let Some((constraints, range)) = &tp.constraints {
+            if constraints.len() < 2 {
+                self.error(
+                    errors,
+                    *range,
+                    ErrorInfo::Kind(ErrorKind::InvalidTypeVar),
+                    format!(
+                        "Expected at least 2 constraints in TypeVar `{}`, got {}",
+                        tp.name,
+                        constraints.len(),
+                    ),
+                );
+                Restriction::Unrestricted
+            } else {
+                let constraint_tys = constraints.map(|constraint| {
+                    self.expr_untype(constraint, TypeFormContext::TypeVarConstraint, errors)
+                });
+                Restriction::Constraints(constraint_tys)
+            }
+        } else {
+            Restriction::Unrestricted
+        };
+        let mut default_ty = None;
+        if let Some(default_expr) = &tp.default {
+            let default = self.expr_untype(
+                default_expr,
+                TypeFormContext::quantified_kind_default(tp.kind),
+                errors,
+            );
+            default_ty = Some(self.validate_type_var_default(
+                &tp.name,
+                tp.kind,
+                &default,
+                default_expr.range(),
+                &restriction,
+                errors,
+            ));
+        }
+        Quantified::new(tp.unique, tp.name.clone(), tp.kind, default_ty, restriction)
+    }
+
+    pub fn scoped_type_params(
+        &self,
+        x: Option<&TypeParams>,
+        errors: &ErrorCollector,
+    ) -> Vec<TParam> {
         match x {
             Some(x) => {
-                let get_quantified = |t: &Type| match t {
-                    Type::QuantifiedValue(q) => (**q).clone(),
-                    _ => unreachable!(
-                        "{}:{:?}: Expected a QuantifiedValue, got {}",
-                        self.module().path().as_path().display(),
-                        x.range(),
-                        t
-                    ),
-                };
                 let mut params = Vec::new();
                 for raw_param in x.type_params.iter() {
                     let name = raw_param.name();
-                    let quantified =
-                        get_quantified(self.get(&Key::Definition(ShortIdentifier::new(name))).ty());
+                    let key = Key::Definition(ShortIdentifier::new(name));
+                    let idx = self.bindings().key_to_idx(&key);
+                    let binding = self.bindings().get(idx);
+                    let quantified = match binding {
+                        Binding::TypeParameter(tp) => {
+                            self.quantified_from_type_parameter(tp, errors)
+                        }
+                        _ => unreachable!(
+                            "{}:{:?}: Expected a TypeParameter binding, got {:?}",
+                            self.module().path().as_path().display(),
+                            x.range(),
+                            binding
+                        ),
+                    };
                     params.push(TParam {
                         quantified,
                         variance: PreInferenceVariance::PUndefined,
@@ -3430,57 +3486,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             },
             Binding::Type(x) => x.clone(),
             Binding::Global(global) => global.as_type(self.stdlib),
-            Binding::TypeParameter(box TypeParameter {
-                name,
-                unique,
-                kind,
-                bound,
-                default,
-                constraints,
-            }) => {
-                let restriction = if let Some(bound) = bound {
-                    let bound_ty =
-                        self.expr_untype(bound, TypeFormContext::TypeVarConstraint, errors);
-                    Restriction::Bound(bound_ty)
-                } else if let Some((constraints, range)) = constraints {
-                    if constraints.len() < 2 {
-                        self.error(
-                            errors,
-                            *range,
-                            ErrorInfo::Kind(ErrorKind::InvalidTypeVar),
-                            format!(
-                                "Expected at least 2 constraints in TypeVar `{}`, got {}",
-                                name,
-                                constraints.len(),
-                            ),
-                        );
-                        Restriction::Unrestricted
-                    } else {
-                        let constraint_tys = constraints.map(|constraint| {
-                            self.expr_untype(constraint, TypeFormContext::TypeVarConstraint, errors)
-                        });
-                        Restriction::Constraints(constraint_tys)
-                    }
-                } else {
-                    Restriction::Unrestricted
-                };
-                let mut default_ty = None;
-                if let Some(default_expr) = default {
-                    let default = self.expr_untype(
-                        default_expr,
-                        TypeFormContext::quantified_kind_default(*kind),
-                        errors,
-                    );
-                    default_ty = Some(self.validate_type_var_default(
-                        name,
-                        *kind,
-                        &default,
-                        default_expr.range(),
-                        &restriction,
-                        errors,
-                    ));
-                }
-                Quantified::new(*unique, name.clone(), *kind, default_ty, restriction).to_value()
+            Binding::TypeParameter(tp) => {
+                self.quantified_from_type_parameter(tp, errors).to_value()
             }
             Binding::Module(m, path, prev) => {
                 let prev = prev
@@ -3516,7 +3523,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         let params_range = params.as_ref().map_or(expr.range(), |x| x.range);
                         Forallable::TypeAlias(*ta).forall(self.validated_tparams(
                             params_range,
-                            self.scoped_type_params(params.as_ref()),
+                            self.scoped_type_params(params.as_ref(), errors),
                             TParamsSource::TypeAlias,
                             errors,
                         ))

pyrefly/lib/test/generic_basic.rs

@@ -68,6 +68,14 @@ class C[T](Generic[T]):  # E: Redundant
     "#,
 );
 
+testcase!(
+    test_class_type_params_can_reference_class,
+    r#"
+class C[T: C](set[object]):
+    pass
+    "#,
+);
+
 testcase!(
     test_type_argument_error_default,
     r#"