pyrefly 0.20.1__tar.gz → 0.21.0__tar.gz

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

@@ -157,9 +157,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.95"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "append-only-vec"
@@ -892,6 +892,15 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
 [[package]]
 name = "fxhash"
 version = "0.2.1"
@@ -1330,6 +1339,16 @@ version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.3"
@@ -1454,6 +1473,15 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "mimalloc"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.6.2"
@@ -1841,11 +1869,10 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.20.1"
+version = "0.21.0"
 dependencies = [
  "anstream",
  "anyhow",
- "append-only-vec",
  "base64",
  "blake3",
  "clap",
@@ -1855,10 +1882,12 @@ dependencies = [
  "dupe",
  "enum-iterator",
  "equivalent",
+ "fuzzy-matcher",
  "indicatif",
  "itertools 0.14.0",
  "lsp-server",
  "lsp-types",
+ "mimalloc",
  "num-bigint",
  "num-traits",
  "parse-display",
@@ -1899,7 +1928,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.20.1"
+version = "0.21.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1908,10 +1937,11 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.20.1"
+version = "0.21.0"
 dependencies = [
  "anstream",
  "anyhow",
+ "append-only-vec",
  "argfile",
  "bstr",
  "const-str",

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

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

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.20.1"
+version = "0.21.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -18,8 +18,7 @@ path = "bin/main.rs"
 
 [dependencies]
 anstream = "0.6.11"
-anyhow = "1.0.95"
-append-only-vec = "0.1.2"
+anyhow = "1.0.98"
 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"] }
@@ -29,6 +28,7 @@ crossbeam-channel = "0.5.15"
 dupe = "0.9.1"
 enum-iterator = "1.4.1"
 equivalent = "1.0"
+fuzzy-matcher = "0.3.7"
 indicatif = { version = "0.17.6", features = ["futures", "improved_unicode", "rayon", "tokio"] }
 itertools = "0.14.0"
 lsp-server = "0.7.2"
@@ -83,5 +83,8 @@ zstd = { version = "0.13", features = ["experimental", "zstdmt"] }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 zstd = "0.13"
 
+[target.'cfg(target_os = "windows")'.dependencies]
+mimalloc = "0.1.46"
+
 [lints]
 rust = { unexpected_cfgs = { check-cfg = ["cfg(fbcode_build)"], level = "warn" } }

{pyrefly-0.20.1 → pyrefly-0.21.0}/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;
@@ -50,6 +51,10 @@ use tracing::info;
 #[cfg(all(any(target_os = "linux", target_os = "macos"), not(fbcode_build)))]
 static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
+#[global_allocator]
+#[cfg(target_os = "windows")]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 #[derive(Debug, Parser)]
 #[command(name = "pyrefly")]
 #[command(about = "Next generation of Pyre type checker", long_about = None)]
@@ -170,6 +175,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 +227,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 +244,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.21.0}/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,52 @@ impl Solutions {
     }
 }
 
+/// Compactly represents the identity of a binding, for the purposes of
+/// understanding the calculation stack.
+#[derive(Debug, Clone, Dupe)]
+pub struct CalcId(pub Bindings, pub AnyIdx);
+
+impl PartialEq for CalcId {
+    fn eq(&self, other: &Self) -> bool {
+        (self.0.module_info(), &self.1) == (other.0.module_info(), &other.1)
+    }
+}
+
+/// 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 CalcStack(RefCell<Vec<CalcId>>);
+
+impl CalcStack {
+    pub fn new() -> Self {
+        Self(RefCell::new(Vec::new()))
+    }
+
+    fn push(&self, bindings: Bindings, idx: AnyIdx) {
+        self.0.borrow_mut().push(CalcId(bindings, idx));
+    }
+
+    fn pop(&self) -> Option<CalcId> {
+        self.0.borrow_mut().pop()
+    }
+
+    pub fn peek(&self) -> Option<CalcId> {
+        self.0.borrow().last().cloned()
+    }
+
+    pub fn into_vec(&self) -> Vec<CalcId> {
+        self.0.borrow().clone()
+    }
+}
+
 pub struct AnswersSolver<'a, Ans: LookupAnswer> {
     answers: &'a Ans,
     current: &'a Answers,
+    stack: &'a CalcStack,
     // 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 +389,7 @@ pub trait LookupAnswer: Sized {
         module: ModuleName,
         path: Option<&ModulePath>,
         k: &K,
+        stack: &CalcStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -441,6 +487,7 @@ impl Answers {
         let answers_solver = AnswersSolver {
             stdlib,
             answers,
+            stack: &CalcStack::new(),
             bindings,
             base_errors: errors,
             exports,
@@ -508,6 +555,7 @@ impl Answers {
         stdlib: &Stdlib,
         uniques: &UniqueFactory,
         key: Hashed<&K>,
+        stack: &CalcStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -522,6 +570,7 @@ impl Answers {
             exports,
             recurser: &Recurser::new(),
             current: self,
+            stack,
         };
         let v = solver.get_hashed(key);
         let mut vv = (*v).clone();
@@ -540,6 +589,10 @@ impl Answers {
         self.solver.for_display(t)
     }
 
+    pub fn solver(&self) -> &Solver {
+        &self.solver
+    }
+
     pub fn get_type_trace(&self, range: TextRange) -> Option<Arc<Type>> {
         let lock = self.trace.as_ref()?.lock();
         lock.types.get(&range).duped()
@@ -591,6 +644,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         uniques: &'a UniqueFactory,
         recurser: &'a Recurser<Var>,
         stdlib: &'a Stdlib,
+        stack: &'a CalcStack,
     ) -> AnswersSolver<'a, Ans> {
         AnswersSolver {
             stdlib,
@@ -601,6 +655,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             exports,
             recurser,
             current,
+            stack,
         }
     }
 
@@ -616,6 +671,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self.current.solver
     }
 
+    pub fn stack(&self) -> &CalcStack {
+        self.stack
+    }
+
     pub fn for_display(&self, t: Type) -> Type {
         self.solver().for_display(t)
     }
@@ -636,7 +695,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 +738,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
     {
         let calculation = self.get_calculation(idx);
+        self.stack.push(self.bindings().dupe(), K::to_anyidx(idx));
         let result = calculation.calculate_with_recursive(
             || {
                 let binding = self.bindings().get(idx);
@@ -693,6 +753,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)),
@@ -901,9 +962,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn error_swallower(&self) -> ErrorCollector {
         ErrorCollector::new(self.module_info().dupe(), ErrorStyle::Never)
     }
-}
 
-impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn record_external_attribute_definition_index(
         &self,
         base: &Type,

{pyrefly-0.20.1 → pyrefly-0.21.0}/pyrefly/lib/alt/attr.rs

@@ -136,12 +136,16 @@ impl AttrSubsetError {
                     ", the type of "
                 };
                 format!(
-                    "{got_desc}`{child_class}.{attr_name}` has type `{got}`, which is not assignable to `{want}`{want_desc}`{parent_class}.{attr_name}`"
+                    "{got_desc}`{child_class}.{attr_name}` has type `{}`, which is not assignable to `{}`{want_desc}`{parent_class}.{attr_name}`",
+                    got.deterministic_printing(),
+                    want.deterministic_printing()
                 )
             }
             AttrSubsetError::Invariant { got, want } => {
                 format!(
-                    "`{child_class}.{attr_name}` has type `{got}`, which is not consistent with `{want}` in `{parent_class}.{attr_name}` (the type of read-write attributes cannot be changed)"
+                    "`{child_class}.{attr_name}` has type `{}`, which is not consistent with `{}` in `{parent_class}.{attr_name}` (the type of read-write attributes cannot be changed)",
+                    got.deterministic_printing(),
+                    want.deterministic_printing()
                 )
             }
             AttrSubsetError::Contravariant {
@@ -155,7 +159,9 @@ impl AttrSubsetError {
                     ""
                 };
                 format!(
-                    "{desc}`{child_class}.{attr_name}` has type `{got}`, which is not assignable from `{want}`, the property getter for `{parent_class}.{attr_name}`"
+                    "{desc}`{child_class}.{attr_name}` has type `{}`, which is not assignable from `{}`, the property getter for `{parent_class}.{attr_name}`",
+                    got.deterministic_printing(),
+                    want.deterministic_printing()
                 )
             }
         }
@@ -1297,9 +1303,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     /// on the metaclass instead of class `A` (i.e. we are looking for `type.__magic_dunder_attr__`
     /// instead of `A.__magic_dunder_attr__`).
     fn lookup_magic_dunder_attr(&self, base: AttributeBase, dunder_name: &Name) -> LookupResult {
-        match base {
+        match &base {
             AttributeBase::ClassObject(class) => {
-                let metadata = self.get_metadata_for_class(&class);
+                let metadata = self.get_metadata_for_class(class);
                 let metaclass = metadata.metaclass().unwrap_or(self.stdlib.builtins_type());
                 match self.get_instance_attribute(metaclass, dunder_name) {
                     Some(attr) => LookupResult::Found(attr),
@@ -1308,7 +1314,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     )),
                 }
             }
-            base => self.lookup_attr_from_attribute_base(base, dunder_name),
+            AttributeBase::ClassInstance(cls)
+            | AttributeBase::EnumLiteral(cls, _, _)
+            | AttributeBase::TypeVar(_, Some(cls))
+                if (*dunder_name == dunder::SETATTR || *dunder_name == dunder::DELATTR)
+                    && self.method_is_inherited_from_object(cls, dunder_name) =>
+            {
+                LookupResult::NotFound(NotFound::Attribute(cls.class_object().clone()))
+            }
+
+            _ => self.lookup_attr_from_attribute_base(base, dunder_name),
         }
     }
 
@@ -1494,7 +1509,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Some(AttributeBase::ClassObject(class.class_object().dupe()))
             }
             Type::Type(box Type::Quantified(q)) if q.is_type_var() => match q.restriction() {
-                // TODO(#119): this is wrong, because we lose the information that this is a type var
+                // TODO(https://github.com/facebook/pyrefly/issues/514)
+                // this is wrong, because we lose the information that this is a type var
                 Restriction::Bound(bound) => {
                     self.as_attribute_base_no_union(Type::type_form(bound.clone()))
                 }
@@ -1553,15 +1569,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 }
             }
             Type::SuperInstance(box (cls, obj)) => Some(AttributeBase::SuperInstance(cls, obj)),
-            Type::Quantified(q) if q.is_type_var() => match q.restriction() {
-                // TODO(#119): this is wrong, because we lose the information that this is a type var
-                Restriction::Bound(bound) => self.as_attribute_base_no_union(bound.clone()),
-                // TODO: handle constraints
-                Restriction::Constraints(_) => None,
-                Restriction::Unrestricted => {
-                    Some(AttributeBase::ClassInstance(self.stdlib.object().clone()))
-                }
-            },
             // TODO: check to see which ones should have class representations
             Type::Union(_)
             | Type::SpecialForm(_)

{pyrefly-0.20.1 → pyrefly-0.21.0}/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;
@@ -208,6 +207,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::TypedDict(typed_dict)) => {
                 Some(CallTarget::new(Target::TypedDict(typed_dict)))
             }
+            // TODO: this is wrong, because we lose the information that this is a type variable
+            // TODO: handle type[T]
             Type::Quantified(q) if q.is_type_var() => match q.restriction() {
                 Restriction::Bound(bound) => self.as_call_target(bound.clone()),
                 // TODO: handle constraints
@@ -576,7 +577,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 };
                 let self_obj = match first_arg_type {
                     Some(Type::Type(box Type::ClassType(c))) => Some(c.to_type()),
-                    Some(Type::ClassDef(class)) => Some(class.as_class_type().to_type()),
+                    Some(Type::ClassDef(class)) => {
+                        Some(self.as_class_type_unchecked(&class).to_type())
+                    }
                     _ => None,
                 };
                 if let Some(self_obj) = self_obj {
@@ -655,8 +658,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.21.0}/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;
                 }