Add option to expand unfinished quantified

Summary:
Adds `expand_unfinished_quantified` parameter to `Solver::expand_with_limit` that will control whether we expand Quantified variables to their lower bounds. The parameter doesn't do anything yet, but this diff shows where we intend to expand:
* in `expand_dimension`, which is currently relying on eager pinning to get answers for vars when they are expanded
* in `for_display`, which should expand to eliminate `_` in error messages

For #105.

Reviewed By: yangdanny97

Differential Revision: D96547435

fbshipit-source-id: 9e8ba75b7619cb0cf615cc81ddd6fc5ffe00d49a

Author: rchen152

pyrefly/lib/solver/solver.rs

@@ -429,7 +429,7 @@ impl Solver {
     /// Finish the type returned from a function call. This entails expanding solved variables and
     /// erasing unsolved variables without defaults from unions.
     pub fn finish_function_return(&self, mut t: Type) -> Type {
-        self.expand_with_limit(&mut t, TYPE_LIMIT, &VarRecurser::new());
+        self.expand_with_limit(&mut t, TYPE_LIMIT, &VarRecurser::new(), false);
         self.erase_unsolved_variables(&mut t);
         self.simplify_mut(&mut t);
         t
@@ -447,14 +447,21 @@ impl Solver {
 
     /// Like `expand`, but when you have a `&mut`.
     pub fn expand_vars_mut(&self, t: &mut Type) {
-        self.expand_with_limit(t, TYPE_LIMIT, &VarRecurser::new());
+        self.expand_with_limit(t, TYPE_LIMIT, &VarRecurser::new(), false);
         // After we substitute bound variables, we may be able to simplify some types
         self.simplify_mut(t);
     }
 
     /// Expand, but if the resulting type will be greater than limit levels deep, return an `Any`.
     /// Avoids producing things that stack overflow later in the process.
-    fn expand_with_limit(&self, t: &mut Type, limit: usize, recurser: &VarRecurser) {
+    #[expect(clippy::only_used_in_recursion)]
+    fn expand_with_limit(
+        &self,
+        t: &mut Type,
+        limit: usize,
+        recurser: &VarRecurser,
+        expand_unfinished_quantified: bool,
+    ) {
         if limit == 0 {
             // TODO: Should probably add an error here, and use any_error,
             // but don't have any good location information to hand.
@@ -468,22 +475,29 @@ impl Solver {
                         *t = ty.clone();
                         drop(variable);
                         drop(lock);
-                        self.expand_with_limit(t, limit - 1, recurser);
+                        self.expand_with_limit(
+                            t,
+                            limit - 1,
+                            recurser,
+                            expand_unfinished_quantified,
+                        );
                     }
                     _ => {}
                 }
             } else {
                 *t = self.heap.mk_any_implicit();
             }
         } else {
-            t.recurse_mut(&mut |t| self.expand_with_limit(t, limit - 1, recurser));
+            t.recurse_mut(&mut |t| {
+                self.expand_with_limit(t, limit - 1, recurser, expand_unfinished_quantified)
+            });
         }
     }
 
     /// Public wrapper to expand a dimension type by resolving bound Vars.
     /// Used by subset checking to expand Vars before comparing dimension expressions.
     pub fn expand_dimension(&self, dim_ty: &mut Type) {
-        self.expand_with_limit(dim_ty, TYPE_LIMIT, &VarRecurser::new());
+        self.expand_with_limit(dim_ty, TYPE_LIMIT, &VarRecurser::new(), true);
     }
 
     /// Given a `Var`, ensures that the solver has an answer for it (or inserts Any if not already),
@@ -1066,7 +1080,7 @@ impl Solver {
     }
 
     pub fn for_display(&self, mut t: Type) -> Type {
-        self.expand_with_limit(&mut t, TYPE_LIMIT, &VarRecurser::new());
+        self.expand_with_limit(&mut t, TYPE_LIMIT, &VarRecurser::new(), true);
         self.simplify_mut(&mut t);
         t.deterministic_printing()
     }