pyrefly 0.20.1__tar.gz → 0.20.2__tar.gz

{pyrefly-0.20.1 → pyrefly-0.20.2}/Cargo.lock

@@ -1841,11 +1841,10 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.20.1"
+version = "0.20.2"
 dependencies = [
  "anstream",
  "anyhow",
- "append-only-vec",
  "base64",
  "blake3",
  "clap",
@@ -1899,7 +1898,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.20.1"
+version = "0.20.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1908,10 +1907,11 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.20.1"
+version = "0.20.2"
 dependencies = [
  "anstream",
  "anyhow",
+ "append-only-vec",
  "argfile",
  "bstr",
  "const-str",

{pyrefly-0.20.1 → pyrefly-0.20.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.20.1
+Version: 0.20.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.20.1"
+version = "0.20.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -19,7 +19,6 @@ path = "bin/main.rs"
 [dependencies]
 anstream = "0.6.11"
 anyhow = "1.0.95"
-append-only-vec = "0.1.2"
 base64 = { version = "0.22.1", features = ["alloc"] }
 blake3 = { version = "=1.6.1", features = ["mmap", "rayon", "traits-preview"] }
 clap = { version = "4.5.38", features = ["derive", "env", "string", "unicode", "wrap_help"] }

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/bin/main.rs

@@ -32,6 +32,7 @@ use library::run::LspArgs;
 use library::standard_config_finder;
 use path_absolutize::Absolutize;
 use pyrefly::library::library::library::library;
+use pyrefly::library::library::library::library::Severity;
 use pyrefly::library::library::library::library::finder::ConfigError;
 use pyrefly_util::arc_id::ArcId;
 use pyrefly_util::args::clap_env;
@@ -170,6 +171,18 @@ fn get_explicit_config(
     )
 }
 
+fn add_config_errors(config_finder: &ConfigFinder, errors: Vec<ConfigError>) -> anyhow::Result<()> {
+    if errors.iter().any(|e| e.severity() == Severity::Error) {
+        for e in errors {
+            e.print();
+        }
+        Err(anyhow::anyhow!("Fatal configuration error"))
+    } else {
+        config_finder.add_errors(errors);
+        Ok(())
+    }
+}
+
 /// Get inputs for a full-project check. We will look for a config file and type-check the project it defines.
 fn get_globs_and_config_for_project(
     config: Option<PathBuf>,
@@ -210,7 +223,7 @@ fn get_globs_and_config_for_project(
 
     // We want our config_finder to never actually
     let config_finder = ConfigFinder::new_constant(config.dupe());
-    config_finder.add_errors(errors);
+    add_config_errors(&config_finder, errors)?;
 
     debug!("Config is: {}", config);
 
@@ -227,15 +240,33 @@ fn get_globs_and_config_for_files(
 ) -> anyhow::Result<(FilteredGlobs, ConfigFinder)> {
     let project_excludes = project_excludes.unwrap_or_else(ConfigFile::default_project_excludes);
     let files_to_check = absolutize(files_to_check)?;
-    let config_finder = match config {
+    let (config_finder, errors) = match config {
         Some(explicit) => {
             let (config, errors) = get_explicit_config(&explicit, args);
             let config_finder = ConfigFinder::new_constant(config);
-            config_finder.add_errors(errors);
-            config_finder
+            (config_finder, errors)
+        }
+        None => {
+            let config_finder = config_finder(args.clone());
+            // If there is only one input and one root, we treat config parse errors as fatal,
+            // so that `pyrefly check .` exits immediately on an unparseable config, matching the
+            // behavior of `pyrefly check` (see get_globs_and_config_for_project).
+            let solo_root = if files_to_check.len() == 1 {
+                files_to_check.roots().first().cloned()
+            } else {
+                None
+            };
+            if let Some(root) = solo_root {
+                // We don't care about the contents of the config, only if we generated any errors while parsing it.
+                config_finder.directory(&root);
+                let errors = config_finder.errors();
+                (config_finder, errors)
+            } else {
+                (config_finder, Vec::new())
+            }
         }
-        None => config_finder(args.clone()),
     };
+    add_config_errors(&config_finder, errors)?;
     Ok((
         FilteredGlobs::new(files_to_check, project_excludes),
         config_finder,

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/lib/alt/answers.rs

@@ -5,6 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+use std::cell::RefCell;
 use std::fmt;
 use std::fmt::Debug;
 use std::fmt::Display;
@@ -32,6 +33,7 @@ use crate::alt::attr::AttrDefinition;
 use crate::alt::attr::AttrInfo;
 use crate::alt::traits::Solve;
 use crate::alt::traits::SolveRecursive;
+use crate::binding::binding::AnyIdx;
 use crate::binding::binding::Binding;
 use crate::binding::binding::Exported;
 use crate::binding::binding::Key;
@@ -324,9 +326,41 @@ impl Solutions {
     }
 }
 
+/// Represent a stack of in-progress calculations in an `AnswersSolver`.
+///
+/// This is useful for debugging, particularly for debugging cycle handling.
+///
+/// The stack is per-thread; we create a new `AnswersSolver` every time
+/// we change modules when resolving exports, but the stack is passed
+/// down because cycles can cross module boundaries.
+pub struct CalculationStack(RefCell<Vec<(ModuleInfo, AnyIdx)>>);
+
+impl CalculationStack {
+    pub fn new() -> Self {
+        Self(RefCell::new(Vec::new()))
+    }
+
+    fn push(&self, module_info: ModuleInfo, idx: AnyIdx) {
+        self.0.borrow_mut().push((module_info, idx));
+    }
+
+    fn pop(&self) -> Option<(ModuleInfo, AnyIdx)> {
+        self.0.borrow_mut().pop()
+    }
+
+    pub fn peek(&self) -> Option<(ModuleInfo, AnyIdx)> {
+        self.0.borrow().last().cloned()
+    }
+
+    pub fn into_vec(&self) -> Vec<(ModuleInfo, AnyIdx)> {
+        self.0.borrow().clone()
+    }
+}
+
 pub struct AnswersSolver<'a, Ans: LookupAnswer> {
     answers: &'a Ans,
     current: &'a Answers,
+    stack: &'a CalculationStack,
     // The base solver is only used to reset the error collector at binding
     // boundaries. Answers code should generally use the error collector passed
     // along the call stack instead.
@@ -344,6 +378,7 @@ pub trait LookupAnswer: Sized {
         module: ModuleName,
         path: Option<&ModulePath>,
         k: &K,
+        stack: &CalculationStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -441,6 +476,7 @@ impl Answers {
         let answers_solver = AnswersSolver {
             stdlib,
             answers,
+            stack: &CalculationStack::new(),
             bindings,
             base_errors: errors,
             exports,
@@ -508,6 +544,7 @@ impl Answers {
         stdlib: &Stdlib,
         uniques: &UniqueFactory,
         key: Hashed<&K>,
+        stack: &CalculationStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -522,6 +559,7 @@ impl Answers {
             exports,
             recurser: &Recurser::new(),
             current: self,
+            stack,
         };
         let v = solver.get_hashed(key);
         let mut vv = (*v).clone();
@@ -591,6 +629,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         uniques: &'a UniqueFactory,
         recurser: &'a Recurser<Var>,
         stdlib: &'a Stdlib,
+        stack: &'a CalculationStack,
     ) -> AnswersSolver<'a, Ans> {
         AnswersSolver {
             stdlib,
@@ -601,6 +640,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             exports,
             recurser,
             current,
+            stack,
         }
     }
 
@@ -616,6 +656,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self.current.solver
     }
 
+    pub fn stack(&self) -> &CalculationStack {
+        self.stack
+    }
+
     pub fn for_display(&self, t: Type) -> Type {
         self.solver().for_display(t)
     }
@@ -636,7 +680,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         {
             self.get(k)
         } else {
-            self.answers.get(module, path, k)
+            self.answers.get(module, path, k, self.stack)
         }
     }
 
@@ -679,6 +723,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
     {
         let calculation = self.get_calculation(idx);
+        self.stack
+            .push(self.module_info().dupe(), K::to_anyidx(idx));
         let result = calculation.calculate_with_recursive(
             || {
                 let binding = self.bindings().get(idx);
@@ -693,6 +739,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             let k = self.bindings().idx_to_key(idx).range();
             K::record_recursive(self, k, v, r, self.base_errors);
         }
+        self.stack.pop();
         match result {
             Ok((v, _)) => v,
             Err(r) => Arc::new(K::promote_recursive(r)),

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/lib/alt/call.rs

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-use append_only_vec::AppendOnlyVec;
 use dupe::Dupe;
 use ruff_python_ast::name::Name;
 use ruff_text_size::TextRange;
@@ -655,8 +654,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // If we infer them for each overload, we may end up infering them multiple times.
         // If those overloads contain nested overloads, then we can easily end up with O(2^n) perf.
         // Therefore, flatten all TypeOrExpr's into Type before we start
-        let type_store = AppendOnlyVec::new();
-        let call = CallWithTypes::new(&type_store);
+        let call = CallWithTypes::new();
         let self_arg = call.opt_call_arg(self_arg.as_ref(), self, errors);
         let args = call.vec_call_arg(args, self, errors);
         let keywords = call.vec_call_keyword(keywords, self, errors);

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/lib/alt/callable.rs

@@ -5,9 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-use append_only_vec::AppendOnlyVec;
 use itertools::Itertools;
 use pyrefly_util::display::count;
+use pyrefly_util::owner::Owner;
 use pyrefly_util::prelude::SliceExt;
 use pyrefly_util::prelude::VecExt;
 use ruff_python_ast::Expr;
@@ -40,15 +40,19 @@ use crate::types::tuple::Tuple;
 use crate::types::types::Type;
 use crate::types::types::Var;
 
-pub struct CallWithTypes<'a>(&'a AppendOnlyVec<Type>);
+/// Structure to turn TypeOrExprs into Types.
+/// This is used to avoid re-infering types for arguments multiple types.
+///
+/// Implemented by keeping an `Owner` to hand out references to `Type`.
+pub struct CallWithTypes(Owner<Type>);
 
-impl<'a> CallWithTypes<'a> {
-    pub fn new(x: &'a AppendOnlyVec<Type>) -> Self {
-        Self(x)
+impl CallWithTypes {
+    pub fn new() -> Self {
+        Self(Owner::new())
     }
 
-    pub fn type_or_expr<'b: 'a, Ans: LookupAnswer>(
-        &self,
+    pub fn type_or_expr<'a, 'b: 'a, Ans: LookupAnswer>(
+        &'a self,
         x: TypeOrExpr<'b>,
         solver: &AnswersSolver<Ans>,
         errors: &ErrorCollector,
@@ -56,15 +60,14 @@ impl<'a> CallWithTypes<'a> {
         match x {
             TypeOrExpr::Expr(e) => {
                 let t = solver.expr_infer(e, errors);
-                let i = self.0.push(t);
-                TypeOrExpr::Type(&self.0[i], e.range())
+                TypeOrExpr::Type(self.0.push(t), e.range())
             }
             TypeOrExpr::Type(t, r) => TypeOrExpr::Type(t, r),
         }
     }
 
-    pub fn call_arg<'b: 'a, Ans: LookupAnswer>(
-        &self,
+    pub fn call_arg<'a, 'b: 'a, Ans: LookupAnswer>(
+        &'a self,
         x: &CallArg<'b>,
         solver: &AnswersSolver<Ans>,
         errors: &ErrorCollector,
@@ -75,8 +78,8 @@ impl<'a> CallWithTypes<'a> {
         }
     }
 
-    pub fn call_keyword<'b: 'a, Ans: LookupAnswer>(
-        &self,
+    pub fn call_keyword<'a, 'b: 'a, Ans: LookupAnswer>(
+        &'a self,
         x: &CallKeyword<'b>,
         solver: &AnswersSolver<Ans>,
         errors: &ErrorCollector,
@@ -88,8 +91,8 @@ impl<'a> CallWithTypes<'a> {
         }
     }
 
-    pub fn opt_call_arg<'b: 'a, Ans: LookupAnswer>(
-        &self,
+    pub fn opt_call_arg<'a, 'b: 'a, Ans: LookupAnswer>(
+        &'a self,
         x: Option<&CallArg<'b>>,
         solver: &AnswersSolver<Ans>,
         errors: &ErrorCollector,
@@ -97,8 +100,8 @@ impl<'a> CallWithTypes<'a> {
         x.map(|x| self.call_arg(x, solver, errors))
     }
 
-    pub fn vec_call_arg<'b: 'a, Ans: LookupAnswer>(
-        &self,
+    pub fn vec_call_arg<'a, 'b: 'a, Ans: LookupAnswer>(
+        &'a self,
         xs: &[CallArg<'b>],
         solver: &AnswersSolver<Ans>,
         errors: &ErrorCollector,
@@ -106,8 +109,8 @@ impl<'a> CallWithTypes<'a> {
         xs.map(|x| self.call_arg(x, solver, errors))
     }
 
-    pub fn vec_call_keyword<'b: 'a, Ans: LookupAnswer>(
-        &self,
+    pub fn vec_call_keyword<'a, 'b: 'a, Ans: LookupAnswer>(
+        &'a self,
         xs: &[CallKeyword<'b>],
         solver: &AnswersSolver<Ans>,
         errors: &ErrorCollector,
@@ -429,7 +432,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let var_to_rparams = |var| {
             let ps = match self.solver().force_var(var) {
                 Type::ParamSpecValue(ps) => ps,
-                Type::Any(_) => ParamList::everything(),
+                Type::Any(_) | Type::Ellipsis => ParamList::everything(),
+                Type::Concatenate(prefix, _) => {
+                    // TODO: handle second component of Type::Concatenate
+                    let ps = ParamList::everything();
+                    ps.prepend_types(&prefix).into_owned()
+                }
                 t => {
                     error(
                         call_errors,
@@ -612,9 +620,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 format!("Expected {expected}, got {actual}"),
             );
         }
-        // Heap storage for typed dict fields, which are freshly calculated (and need to be owned
-        // somewhere) but are used as references.
-        let kwargs_typed_dict_fields_vec = AppendOnlyVec::new();
         // Missing positional-only arguments, split by whether the corresponding parameters
         // in the callable have names. E.g., functions declared with `def` have named posonly
         // parameters and `typing.Callable`s have unnamed ones.
@@ -651,11 +656,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     kwparams.insert(name.clone(), (ty, required == Required::Required));
                 }
                 Param::Kwargs(_, Type::Unpack(box Type::TypedDict(typed_dict))) => {
-                    let i = kwargs_typed_dict_fields_vec.push(self.typed_dict_fields(&typed_dict));
-                    kwargs_typed_dict_fields_vec[i]
-                        .iter()
+                    self.typed_dict_fields(&typed_dict)
+                        .into_iter_hashed()
                         .for_each(|(name, field)| {
-                            kwparams.insert(name.clone(), (field.ty.clone(), field.required));
+                            kwparams.insert_hashed(name, (field.ty, field.required));
                         });
                     kwargs_is_unpack = true;
                 }

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/lib/alt/class/class_field.rs

@@ -13,6 +13,7 @@ use dupe::Dupe;
 use itertools::Itertools;
 use pyrefly_derive::TypeEq;
 use pyrefly_derive::VisitMut;
+use pyrefly_util::owner::Owner;
 use pyrefly_util::prelude::ResultExt;
 use ruff_python_ast::Arguments;
 use ruff_python_ast::Expr;
@@ -947,6 +948,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Type::Forall(box Forall { tparams, .. }) => {
                     let mut qs = SmallSet::new();
                     ty.collect_quantifieds(&mut qs);
+                    let ts = Owner::new();
                     let gradual_fallbacks: SmallMap<_, _> = tparams
                         .iter()
                         .filter_map(|param| {
@@ -963,7 +965,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                         param.name(),
                                     ),
                                 );
-                                Some((q.clone(), q.as_gradual_type()))
+                                Some((q , ts.push(q.as_gradual_type())))
                             } else {
                                 None
                             }

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/lib/alt/class/variance_inference.rs

@@ -23,10 +23,24 @@ use crate::types::types::TParam;
 use crate::types::types::TParams;
 use crate::types::types::Type;
 
-// TODO zeina: This algorithm still needs to handle class properties.
-// To do so, we have to thread class property information to the algorithm
-// After this, we simply call on_type on all class property signatures
-// we have to special case some properties like __init__ and private properties
+// This is our variance inference algorithm, which determines variance based on visiting the structure of the type.
+// There are a couple of TODO that I [zeina] would like to revisit as I figure them out. There are several types that I'm not visiting (and did not visit similar ones in pyre1),
+// And I'm not yet clear what variance inference should do on those:
+
+// Those types are:
+// - Concatenate
+// - Intersect (Our variance inference algorithm is not defined on this. Unclear to me yet what to do on this type.)
+// - Forall (I suspect that we should not visit this, since the forall type is related to a function, and variance makes no sense in the absence of a class definition)
+// - Unpack (potentially just visit the inner type recursively?)
+// - SpecialForm
+// - ParamSpecValue
+// - Args and Kwargs
+// - SuperInstance
+// - TypeGuard
+// - TypeIs
+
+// We need to visit the types that we know are required to be visited for variance inference, and appear in the context of a class with type variables.
+// For example, SelfType is intentionally skipped and should not be visited because it should not be included in the variance calculation.
 
 #[derive(Debug, Clone, PartialEq, Eq, TypeEq)]
 pub struct VarianceMap(pub SmallMap<String, Variance>);

pyrefly-0.20.2/pyrefly/lib/alt/debugging.rs

@@ -0,0 +1,128 @@
+use pyrefly_util::display::DisplayWithCtx;
+
+use crate::alt::answers::AnswersSolver;
+use crate::alt::answers::LookupAnswer;
+use crate::binding::binding::AnyIdx;
+use crate::binding::binding::Binding;
+use crate::binding::binding::Key;
+use crate::binding::binding::Keyed;
+use crate::binding::bindings::BindingEntry;
+use crate::binding::bindings::BindingTable;
+use crate::binding::table::TableKeyed;
+use crate::graph::index::Idx;
+
+/// Debugging helpers for the AnswersSolver.
+///
+/// These are all string-returning functions, which make them potentially less efficient
+/// but more convienient than `Display` implementations because they are easy to use
+/// for string-based comparisons for filtered debugging.
+///
+/// For example, one useful snippet in unit tests is:
+///   let debug = self.show_current_module() == "main";
+///   if debug {
+///      ... dump some information that would be too verbose if printed for stdlib modules ...
+///   }
+#[expect(dead_code)]
+impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
+    pub fn show_idx<K>(&self, idx: Idx<K>) -> String
+    where
+        K: Keyed,
+        BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
+    {
+        format!(
+            "{}",
+            self.bindings()
+                .idx_to_key(idx)
+                .display_with(self.module_info())
+        )
+    }
+
+    pub fn show_binding_generic<K>(&self, binding: &K::Value) -> String
+    where
+        K: Keyed,
+        BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
+    {
+        format!("{}", binding.display_with(self.bindings()))
+    }
+
+    pub fn show_binding(&self, binding: &Binding) -> String {
+        self.show_binding_generic::<Key>(binding)
+    }
+
+    pub fn show_binding_for<K: Keyed>(&self, idx: Idx<K>) -> String
+    where
+        BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
+    {
+        self.show_binding_generic::<K>(self.bindings().get(idx))
+    }
+
+    pub fn show_current_module(&self) -> String {
+        format!("{}", self.module_info().name())
+    }
+
+    pub fn show_any_idx(&self, idx: AnyIdx) -> String {
+        let kind = idx.kind();
+        let key = match idx {
+            AnyIdx::Key(idx) => self.show_idx(idx),
+            AnyIdx::KeyExpect(idx) => self.show_idx(idx),
+            AnyIdx::KeyClass(idx) => self.show_idx(idx),
+            AnyIdx::KeyClassField(idx) => self.show_idx(idx),
+            AnyIdx::KeyVariance(idx) => self.show_idx(idx),
+            AnyIdx::KeyClassSynthesizedFields(idx) => self.show_idx(idx),
+            AnyIdx::KeyExport(idx) => self.show_idx(idx),
+            AnyIdx::KeyFunction(idx) => self.show_idx(idx),
+            AnyIdx::KeyAnnotation(idx) => self.show_idx(idx),
+            AnyIdx::KeyClassMetadata(idx) => self.show_idx(idx),
+            AnyIdx::KeyLegacyTypeParam(idx) => self.show_idx(idx),
+            AnyIdx::KeyYield(idx) => self.show_idx(idx),
+            AnyIdx::KeyYieldFrom(idx) => self.show_idx(idx),
+        };
+        format!("{} :: {}", kind, key)
+    }
+
+    pub fn show_current_idx(&self) -> String {
+        match self.stack().peek() {
+            None => {
+                // In practice we'll never hit this debugging, but there's no need to panic if we do.
+                "(None)".to_owned()
+            }
+            Some((module_info, idx)) => {
+                let module = module_info.name();
+                format!("{} . {}", module, self.show_any_idx(idx))
+            }
+        }
+    }
+
+    pub fn show_current_binding(&self) -> String {
+        match self.stack().peek() {
+            None => {
+                // In practice we'll never hit this debugging, but there's no need to panic if we do.
+                "(None)".to_owned()
+            }
+            Some((_, idx)) => match idx {
+                AnyIdx::Key(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyExpect(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyClass(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyClassField(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyVariance(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyClassSynthesizedFields(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyExport(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyFunction(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyAnnotation(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyClassMetadata(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyLegacyTypeParam(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyYield(idx) => self.show_binding_for(idx),
+                AnyIdx::KeyYieldFrom(idx) => self.show_binding_for(idx),
+            },
+        }
+    }
+
+    pub fn show_current_stack(&self) -> impl Iterator<Item = String> {
+        self.stack()
+            .into_vec()
+            .into_iter()
+            .map(|(module_info, idx)| {
+                format!("{} . {}", module_info.name(), self.show_any_idx(idx))
+            })
+    }
+}

{pyrefly-0.20.1 → pyrefly-0.20.2}/pyrefly/lib/alt/expr.rs

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-use append_only_vec::AppendOnlyVec;
 use dupe::Dupe;
 use num_traits::ToPrimitive;
 use pyrefly_util::prelude::SliceExt;
@@ -1309,8 +1308,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
                     let args;
                     let kws;
-                    let type_store = AppendOnlyVec::new();
-                    let call = CallWithTypes::new(&type_store);
+                    let call = CallWithTypes::new();
                     if ty_fun.is_union() {
                         // If we have a union we will distribute over it, and end up duplicating each function call.
                         args = x
@@ -1577,14 +1575,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let index_ty = self.expr_infer(index_expr, errors);
         match &index_ty {
             Type::Literal(lit) => {
-                if let Some(int_value) = lit.as_index_i64() {
-                    if int_value >= 0
-                        && let Some(byte) = bytes.get(int_value.to_usize().unwrap_or_default())
+                if let Some(idx) = lit.as_index_i64() {
+                    if idx >= 0
+                        && let Some(byte) = idx.to_usize().and_then(|idx| bytes.get(idx))
                     {
                         Type::Literal(Lit::Int(LitInt::new((*byte).into())))
-                    } else if int_value < 0
-                        && let Some(byte) =
-                            bytes.get(bytes.len() - (-int_value).to_usize().unwrap_or_default())
+                    } else if idx < 0
+                        && let Some(byte) = idx
+                            .checked_neg()
+                            .and_then(|idx| idx.to_usize())
+                            .and_then(|idx| bytes.len().checked_sub(idx))
+                            .and_then(|idx| bytes.get(idx))
                     {
                         Type::Literal(Lit::Int(LitInt::new((*byte).into())))
                     } else {
@@ -1594,7 +1595,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             ErrorKind::IndexError,
                             None,
                             format!(
-                                "Index `{int_value}` out of range for bytes with {} elements",
+                                "Index `{idx}` out of range for bytes with {} elements",
                                 bytes.len()
                             ),
                         )