pyrefly 0.22.2__tar.gz → 0.23.0__tar.gz

{pyrefly-0.22.2 → pyrefly-0.23.0}/Cargo.lock

@@ -1872,7 +1872,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.22.2"
+version = "0.23.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1930,7 +1930,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.22.2"
+version = "0.23.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1939,7 +1939,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.22.2"
+version = "0.23.0"
 dependencies = [
  "anyhow",
  "dupe",
@@ -1953,6 +1953,7 @@ dependencies = [
  "ruff_python_parser",
  "ruff_text_size",
  "serde",
+ "starlark_map",
  "static_interner",
  "thiserror 2.0.12",
  "toml",
@@ -1960,7 +1961,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.22.2"
+version = "0.23.0"
 dependencies = [
  "anstream",
  "anyhow",

{pyrefly-0.22.2 → pyrefly-0.23.0}/PKG-INFO

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

{pyrefly-0.22.2 → pyrefly-0.23.0}/crates/pyrefly_python/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.22.2"
+version = "0.23.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -21,6 +21,7 @@ ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c
 ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 ruff_text_size = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
+starlark_map = "0.13.0"
 static_interner = "0.1.1"
 thiserror = "2.0.12"
 

{pyrefly-0.22.2 → pyrefly-0.23.0}/crates/pyrefly_python/src/dunder.rs

@@ -11,6 +11,7 @@ use ruff_python_ast::name::Name;
 pub const AENTER: Name = Name::new_static("__aenter__");
 pub const AEXIT: Name = Name::new_static("__aexit__");
 pub const ALL: Name = Name::new_static("__all__");
+pub const BOOL: Name = Name::new_static("__bool__");
 pub const CALL: Name = Name::new_static("__call__");
 pub const CONTAINS: Name = Name::new_static("__contains__");
 pub const DATACLASS_FIELDS: Name = Name::new_static("__dataclass_fields__");
@@ -41,7 +42,7 @@ pub const POS: Name = Name::new_static("__pos__");
 pub const SET: Name = Name::new_static("__set__");
 pub const SETATTR: Name = Name::new_static("__setattr__");
 pub const SETITEM: Name = Name::new_static("__setitem__");
-pub const BOOL: Name = Name::new_static("__bool__");
+pub const SLOTS: Name = Name::new_static("__slots__");
 
 pub const RICH_CMPS: &[Name] = &[LT, LE, EQ, NE, GT, GE];
 /// Rich comparison methods supplied by the `functools.total_ordering` decorator

{pyrefly-0.22.2 → pyrefly-0.23.0}/crates/pyrefly_python/src/lib.rs

@@ -21,6 +21,8 @@
 
 pub mod ast;
 pub mod dunder;
+pub mod ignore;
 pub mod module_name;
+pub mod module_path;
 pub mod symbol_kind;
 pub mod sys_info;

{pyrefly-0.22.2/pyrefly/lib/module → pyrefly-0.23.0/crates/pyrefly_python/src}/module_path.rs

@@ -12,12 +12,13 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use dupe::Dupe;
-use pyrefly_python::dunder;
-use pyrefly_python::module_name::ModuleName;
 use pyrefly_util::with_hash::WithHash;
 use serde::Serialize;
 use serde::Serializer;
 
+use crate::dunder;
+use crate::module_name::ModuleName;
+
 #[derive(Debug, Clone, Dupe, Copy, PartialEq, Eq, Hash, Default)]
 pub enum ModuleStyle {
     /// .py - executable code.

{pyrefly-0.22.2 → pyrefly-0.23.0}/crates/pyrefly_python/src/sys_info.rs

@@ -226,18 +226,22 @@ impl SysInfo {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, PartialEq, PartialOrd)]
 enum Value {
     Tuple(Vec<Value>),
     String(String),
     Int(i64),
     Bool(bool),
+    /// I know what the value evaluates to when considered truthy, but not it's precise outcome.
+    /// We make sure below that it never compares equal to itself
+    Truthiness(bool),
 }
 
 impl Value {
     fn to_bool(&self) -> bool {
         match self {
             Value::Bool(x) => *x,
+            Value::Truthiness(x) => *x,
             Value::Int(x) => *x != 0,
             Value::String(x) => !x.is_empty(),
             Value::Tuple(x) => !x.is_empty(),
@@ -250,13 +254,14 @@ impl Value {
             (Value::String(_), Value::String(_)) => true,
             (Value::Int(_), Value::Int(_)) => true,
             (Value::Bool(_), Value::Bool(_)) => true,
+            (Value::Truthiness(_), Value::Truthiness(_)) => false, // We don't know if they are the same ype
             _ => false,
         }
     }
 
     fn compare(&self, op: CmpOp, other: &Value) -> Option<bool> {
         if !self.same_type(other) {
-            return None; // Someone got confused
+            return None; // Someone got confused, or we are working with Truthiness
         }
         Some(match op {
             CmpOp::Eq => self == other,
@@ -339,24 +344,34 @@ impl SysInfo {
             Expr::StringLiteral(x) => Some(Value::String(x.value.to_str().to_owned())),
             Expr::BoolOp(x) => match x.op {
                 BoolOp::And => {
-                    let mut last = Value::Bool(true);
+                    let mut res = Some(Value::Bool(true));
                     for x in &x.values {
-                        last = self.evaluate(x)?;
-                        if !last.to_bool() {
-                            break;
+                        match self.evaluate(x) {
+                            None => res = None,
+                            Some(x) => match (x.to_bool(), res.is_none()) {
+                                (false, false) => return Some(x),
+                                (false, true) => return Some(Value::Truthiness(false)),
+                                (true, false) => res = Some(x),
+                                (true, true) => res = None,
+                            },
                         }
                     }
-                    Some(last)
+                    res
                 }
                 BoolOp::Or => {
-                    let mut last = Value::Bool(false);
+                    let mut res = Some(Value::Bool(false));
                     for x in &x.values {
-                        last = self.evaluate(x)?;
-                        if last.to_bool() {
-                            break;
+                        match self.evaluate(x) {
+                            None => res = None,
+                            Some(x) => match (x.to_bool(), res.is_none()) {
+                                (false, false) => res = Some(x),
+                                (false, true) => res = None,
+                                (true, false) => return Some(x),
+                                (true, true) => return Some(Value::Truthiness(true)),
+                            },
                         }
                     }
-                    Some(last)
+                    res
                 }
             },
             Expr::UnaryOp(x) => match x.op {

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.22.2"
+version = "0.23.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/answers.rs

@@ -14,6 +14,7 @@ use std::sync::Arc;
 use dupe::Dupe;
 use dupe::OptionDupedExt;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModulePath;
 use pyrefly_util::display::DisplayWith;
 use pyrefly_util::display::DisplayWithCtx;
 use pyrefly_util::gas::Gas;
@@ -47,7 +48,6 @@ use crate::graph::index::Idx;
 use crate::graph::index_map::IndexMap;
 use crate::module::module_info::ModuleInfo;
 use crate::module::module_info::TextRangeWithModuleInfo;
-use crate::module::module_path::ModulePath;
 use crate::solver::solver::Solver;
 use crate::state::ide::IntermediateDefinition;
 use crate::state::ide::key_to_intermediate_definition;

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/answers_solver.rs

@@ -16,6 +16,7 @@ use dupe::Dupe;
 use dupe::IterDupedExt;
 use itertools::Either;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModulePath;
 use pyrefly_util::display::DisplayWithCtx;
 use pyrefly_util::display::commas_iter;
 use pyrefly_util::recurser::Recurser;
@@ -50,7 +51,6 @@ use crate::graph::calculation::Calculation;
 use crate::graph::calculation::ProposalResult;
 use crate::graph::index::Idx;
 use crate::module::module_info::ModuleInfo;
-use crate::module::module_path::ModulePath;
 use crate::solver::type_order::TypeOrder;
 use crate::types::class::Class;
 use crate::types::stdlib::Stdlib;

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/class/class_field.rs

@@ -43,7 +43,6 @@ use crate::types::annotation::Annotation;
 use crate::types::annotation::Qualifier;
 use crate::types::callable::FuncMetadata;
 use crate::types::callable::Function;
-use crate::types::callable::FunctionKind;
 use crate::types::callable::Param;
 use crate::types::callable::Required;
 use crate::types::class::Class;
@@ -58,7 +57,6 @@ use crate::types::typed_dict::TypedDict;
 use crate::types::typed_dict::TypedDictField;
 use crate::types::types::BoundMethod;
 use crate::types::types::BoundMethodType;
-use crate::types::types::CalleeKind;
 use crate::types::types::Forall;
 use crate::types::types::Forallable;
 use crate::types::types::Overload;
@@ -915,7 +913,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             ClassFieldInitialValue::Class(None) => ClassFieldInitialization::Class(None),
             ClassFieldInitialValue::Class(Some(e)) => {
                 // If this field was created via a call to a dataclass field specifier, extract field flags from the call.
-                if metadata.dataclass_metadata().is_some()
+                if let Some(dm) = metadata.dataclass_metadata()
                     && let Expr::Call(ExprCall {
                         range: _,
                         func,
@@ -926,10 +924,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     // so we can ignore any errors encountered here.
                     let ignore_errors = self.error_swallower();
                     let func_ty = self.expr_infer(func, &ignore_errors);
-                    if matches!(
-                        func_ty.callee_kind(),
-                        Some(CalleeKind::Function(FunctionKind::DataclassField))
-                    ) {
+                    let func_kind = func_ty.callee_kind();
+                    if let Some(func_kind) = func_kind
+                        && dm.field_specifiers.contains(&func_kind)
+                    {
                         let mut map = TypeMap::new();
                         for kw in keywords {
                             if let Some(name) = &kw.arg {

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/class/class_metadata.rs

@@ -37,6 +37,7 @@ use crate::error::kind::ErrorKind;
 use crate::graph::index::Idx;
 use crate::types::callable::FunctionKind;
 use crate::types::class::Class;
+use crate::types::class::ClassKind;
 use crate::types::class::ClassType;
 use crate::types::keywords::DataclassKeywords;
 use crate::types::keywords::DataclassTransformKeywords;
@@ -306,8 +307,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             // This class inherits from a dataclass_transform-ed base class, so its keywords are
             // interpreted as dataclass keywords.
             let map = keywords.clone().into_iter().collect::<OrderedMap<_, _>>();
-            dataclass_from_dataclass_transform =
-                Some(DataclassKeywords::from_type_map(&TypeMap(map), &defaults));
+            dataclass_from_dataclass_transform = Some((
+                DataclassKeywords::from_type_map(&TypeMap(map), &defaults),
+                defaults.field_specifiers,
+            ));
         }
         let typed_dict_metadata = if is_typed_dict {
             // Validate that only 'total' keyword is allowed for TypedDict and determine is_total
@@ -440,6 +443,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     dataclass_metadata = Some(DataclassMetadata {
                         fields: dataclass_fields,
                         kws: DataclassKeywords::new(),
+                        field_specifiers: vec![
+                            CalleeKind::Function(FunctionKind::DataclassField),
+                            CalleeKind::Class(ClassKind::DataclassField),
+                        ],
                     });
                 }
                 // `@dataclass(...)`
@@ -453,6 +460,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             &call.keywords,
                             &DataclassTransformKeywords::new(),
                         ),
+                        field_specifiers: vec![
+                            CalleeKind::Function(FunctionKind::DataclassField),
+                            CalleeKind::Class(ClassKind::DataclassField),
+                        ],
                     });
                 }
                 // `@dataclass_transform(...)`
@@ -464,24 +475,29 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 }
                 // `@foo` where `foo` is decorated with `@dataclass_transform(...)`
                 _ if let Some(defaults) = decorator_ty.dataclass_transform_metadata() => {
-                    dataclass_from_dataclass_transform =
-                        Some(DataclassKeywords::from_type_map(&TypeMap::new(), &defaults));
+                    dataclass_from_dataclass_transform = Some((
+                        DataclassKeywords::from_type_map(&TypeMap::new(), &defaults),
+                        defaults.field_specifiers,
+                    ));
                 }
                 // `@foo(...)` where `foo` is decorated with `@dataclass_transform(...)`
                 _ if let Type::KwCall(call) = decorator_ty
                     && let Some(defaults) =
                         &call.func_metadata.flags.dataclass_transform_metadata =>
                 {
-                    dataclass_from_dataclass_transform =
-                        Some(DataclassKeywords::from_type_map(&call.keywords, defaults));
+                    dataclass_from_dataclass_transform = Some((
+                        DataclassKeywords::from_type_map(&call.keywords, defaults),
+                        defaults.field_specifiers.clone(),
+                    ));
                 }
                 _ => {}
             }
         }
-        if let Some(kws) = dataclass_from_dataclass_transform {
+        if let Some((kws, field_specifiers)) = dataclass_from_dataclass_transform {
             dataclass_metadata = Some(DataclassMetadata {
                 fields: self.get_dataclass_fields(cls, &bases_with_metadata),
                 kws,
+                field_specifiers,
             });
         }
         if is_typed_dict

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/class/dataclass.rs

@@ -22,6 +22,7 @@ use crate::alt::types::class_metadata::ClassSynthesizedFields;
 use crate::alt::types::class_metadata::DataclassMetadata;
 use crate::error;
 use crate::error::collector::ErrorCollector;
+use crate::error::kind::ErrorKind;
 use crate::types::callable::Callable;
 use crate::types::callable::FuncMetadata;
 use crate::types::callable::Function;
@@ -89,6 +90,21 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 self.get_dataclass_match_args(cls, dataclass),
             );
         }
+        if dataclass.kws.slots {
+            // It's a runtime error to set slots=True on a class that already defines __slots__.
+            // Note that inheriting __slots__ from a base class is fine.
+            if cls.contains(&dunder::SLOTS) {
+                self.error(
+                    errors,
+                    cls.range(),
+                    ErrorKind::BadClassDefinition,
+                    None,
+                    "Cannot specify both `slots=True` and `__slots__`".to_owned(),
+                );
+            } else {
+                fields.insert(dunder::SLOTS, self.get_dataclass_slots(cls, dataclass));
+            }
+        }
         // See rules for `__hash__` creation under "unsafe_hash":
         // https://docs.python.org/3/library/dataclasses.html#module-contents
         if dataclass.kws.unsafe_hash || (dataclass.kws.eq && dataclass.kws.frozen) {
@@ -168,7 +184,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         has_seen_default = true;
                     }
                 }
-                params.push(field.as_param(&name, has_default, is_kw_only));
+                params.push(field.as_param(
+                    &field_flags.alias.unwrap_or(name),
+                    has_default,
+                    is_kw_only,
+                ));
             }
         }
 
@@ -193,11 +213,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let ts = if kw_only {
             Vec::new()
         } else {
-            let filtered_fields = self.iter_fields(cls, dataclass, false);
+            let filtered_fields = self.iter_fields(cls, dataclass, true);
             filtered_fields
                 .iter()
                 .filter_map(|(name, _, field_flags)| {
-                    if field_flags.is_kw_only() {
+                    if field_flags.is_kw_only() || !field_flags.init {
                         None
                     } else {
                         Some(Type::Literal(Lit::Str(name.as_str().into())))
@@ -209,6 +229,20 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         ClassSynthesizedField::new(ty)
     }
 
+    fn get_dataclass_slots(
+        &self,
+        cls: &Class,
+        dataclass: &DataclassMetadata,
+    ) -> ClassSynthesizedField {
+        let filtered_fields = self.iter_fields(cls, dataclass, false);
+        let ts = filtered_fields
+            .iter()
+            .map(|(name, _, _)| Type::Literal(Lit::Str(name.as_str().into())))
+            .collect();
+        let ty = Type::Tuple(Tuple::Concrete(ts));
+        ClassSynthesizedField::new(ty)
+    }
+
     fn get_dataclass_rich_comparison_methods(
         &self,
         cls: &Class,

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/function.rs

@@ -11,6 +11,7 @@ use std::sync::Arc;
 use dupe::Dupe;
 use itertools::Either;
 use pyrefly_python::dunder;
+use pyrefly_python::module_path::ModuleStyle;
 use ruff_python_ast::Expr;
 use ruff_python_ast::Identifier;
 use ruff_python_ast::StmtFunctionDef;
@@ -33,7 +34,6 @@ use crate::error::context::TypeCheckContext;
 use crate::error::context::TypeCheckKind;
 use crate::error::kind::ErrorKind;
 use crate::graph::index::Idx;
-use crate::module::module_path::ModuleStyle;
 use crate::module::short_identifier::ShortIdentifier;
 use crate::types::callable::Callable;
 use crate::types::callable::FuncFlags;

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/alt/types/class_metadata.rs

@@ -32,6 +32,7 @@ use crate::types::display::ClassDisplayContext;
 use crate::types::keywords::DataclassKeywords;
 use crate::types::keywords::DataclassTransformKeywords;
 use crate::types::stdlib::Stdlib;
+use crate::types::types::CalleeKind;
 use crate::types::types::Type;
 
 #[derive(Clone, Debug, TypeEq, PartialEq, Eq)]
@@ -384,6 +385,7 @@ pub struct DataclassMetadata {
     /// The dataclass fields, e.g., `{'x'}` for `@dataclass class C: x: int`.
     pub fields: SmallSet<Name>,
     pub kws: DataclassKeywords,
+    pub field_specifiers: Vec<CalleeKind>,
 }
 
 #[derive(Clone, Debug, TypeEq, PartialEq, Eq)]

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/binding/bindings.rs

@@ -471,12 +471,15 @@ pub enum MutableCaptureLookupKind {
 /// An abstraction representing the `Idx<Key>` for a binding that we
 /// are currently constructing, which can be used as a factory to create
 /// usage values for `ensure_expr`.
+///
+/// Note that while it wraps a `Usage`, that usage is always `Usage::CurrentIdx`,
+/// never some other variant.
 #[derive(Debug)]
-pub struct User(Usage);
+pub struct CurrentIdx(Usage);
 
-impl User {
+impl CurrentIdx {
     pub fn new(idx: Idx<Key>) -> Self {
-        Self(Usage::User(idx, SmallSet::new()))
+        Self(Usage::CurrentIdx(idx, SmallSet::new()))
     }
 
     pub fn usage(&mut self) -> &mut Usage {
@@ -485,7 +488,7 @@ impl User {
 
     fn idx(&self) -> Idx<Key> {
         match self.0 {
-            Usage::User(idx, ..) => idx,
+            Usage::CurrentIdx(idx, ..) => idx,
             _ => unreachable!(),
         }
     }
@@ -496,7 +499,7 @@ impl User {
 
     pub fn decompose(self) -> (SmallSet<Idx<Key>>, Idx<Key>) {
         match self.0 {
-            Usage::User(idx, first_used_by) => (first_used_by, idx),
+            Usage::CurrentIdx(idx, first_used_by) => (first_used_by, idx),
             _ => unreachable!(),
         }
     }
@@ -516,8 +519,8 @@ impl<'a> BindingsBuilder<'a> {
 
     /// Declare a `Key` as a usage, which can be used for name lookups. Like `idx_for_promise`,
     /// this is a promise to later provide a `Binding` corresponding this key.
-    pub fn declare_user(&mut self, key: Key) -> User {
-        User::new(self.idx_for_promise(key))
+    pub fn declare_current_idx(&mut self, key: Key) -> CurrentIdx {
+        CurrentIdx::new(self.idx_for_promise(key))
     }
 
     /// Insert a binding into the bindings table immediately, given a `key`
@@ -544,8 +547,8 @@ impl<'a> BindingsBuilder<'a> {
 
     /// Insert a binding into the bindings table, given a `Usage`. This will panic if the usage
     /// is `Usage::NoUsageTracking`.
-    pub fn insert_binding_user(&mut self, user: User, value: Binding) -> Idx<Key> {
-        self.insert_binding_idx(user.into_idx(), value)
+    pub fn insert_binding_current(&mut self, current: CurrentIdx, value: Binding) -> Idx<Key> {
+        self.insert_binding_idx(current.into_idx(), value)
     }
 
     /// Allow access to an `Idx<Key>` given a `LastStmt` coming from a scan of a function body.
@@ -868,19 +871,19 @@ impl<'a> BindingsBuilder<'a> {
         match self.table.types.1.get(flow_idx) {
             Some(Binding::Pin(unpinned_idx, FirstUse::Undetermined)) => match usage {
                 Usage::StaticTypeInformation | Usage::Narrowing => (flow_idx, Some(flow_idx)),
-                Usage::User(..) => (*unpinned_idx, Some(flow_idx)),
+                Usage::CurrentIdx(..) => (*unpinned_idx, Some(flow_idx)),
             },
             Some(Binding::Pin(unpinned_idx, first_use)) => match first_use {
                 FirstUse::DoesNotPin => (flow_idx, None),
                 FirstUse::Undetermined => match usage {
                     Usage::StaticTypeInformation | Usage::Narrowing => (flow_idx, Some(flow_idx)),
-                    Usage::User(..) => (*unpinned_idx, Some(flow_idx)),
+                    Usage::CurrentIdx(..) => (*unpinned_idx, Some(flow_idx)),
                 },
                 FirstUse::UsedBy(usage_idx) => {
                     // Detect secondary reads of the same name from a first use, and make
                     // sure they all use the raw binding rather than the `Pin`.
                     let currently_in_first_use = match usage {
-                        Usage::User(idx, ..) => idx == usage_idx,
+                        Usage::CurrentIdx(idx, ..) => idx == usage_idx,
                         Usage::Narrowing | Usage::StaticTypeInformation => false,
                     };
                     if currently_in_first_use {
@@ -899,7 +902,7 @@ impl<'a> BindingsBuilder<'a> {
         match self.table.types.1.get_mut(used) {
             Some(Binding::Pin(.., first_use @ FirstUse::Undetermined)) => {
                 *first_use = match usage {
-                    Usage::User(use_idx, first_uses_of) => {
+                    Usage::CurrentIdx(use_idx, first_uses_of) => {
                         first_uses_of.insert(used);
                         FirstUse::UsedBy(*use_idx)
                     }
@@ -1006,24 +1009,24 @@ impl<'a> BindingsBuilder<'a> {
         self.bind_key(&name.id, idx, style).0
     }
 
-    pub fn bind_definition_user(
+    pub fn bind_definition_current(
         &mut self,
         name: &Identifier,
-        user: User,
+        current: CurrentIdx,
         binding: Binding,
         style: FlowStyle,
     ) -> Option<Idx<KeyAnnotation>> {
-        let idx = self.insert_binding_user(user, binding);
+        let idx = self.insert_binding_current(current, binding);
         self.bind_key(&name.id, idx, style).0
     }
 
-    pub fn bind_user(
+    pub fn bind_current(
         &mut self,
         name: &Name,
-        user: &User,
+        current: &CurrentIdx,
         style: FlowStyle,
     ) -> (Option<Idx<KeyAnnotation>>, Option<Idx<Key>>) {
-        self.bind_key(name, user.idx(), style)
+        self.bind_key(name, current.idx(), style)
     }
 
     /// Return a pair of:

{pyrefly-0.22.2 → pyrefly-0.23.0}/pyrefly/lib/binding/class.rs

@@ -50,8 +50,8 @@ use crate::binding::binding::KeyClassSynthesizedFields;
 use crate::binding::binding::KeyTParams;
 use crate::binding::binding::KeyVariance;
 use crate::binding::bindings::BindingsBuilder;
+use crate::binding::bindings::CurrentIdx;
 use crate::binding::bindings::LegacyTParamBuilder;
-use crate::binding::bindings::User;
 use crate::binding::scope::ClassIndices;
 use crate::binding::scope::FlowStyle;
 use crate::binding::scope::InstanceAttribute;
@@ -87,7 +87,7 @@ impl<'a> BindingsBuilder<'a> {
         res
     }
 
-    fn class_object_and_indices(&mut self, class_name: &Identifier) -> (User, ClassIndices) {
+    fn class_object_and_indices(&mut self, class_name: &Identifier) -> (CurrentIdx, ClassIndices) {
         let def_index = self.def_index();
         let class_indices = ClassIndices {
             def_index,
@@ -99,7 +99,8 @@ impl<'a> BindingsBuilder<'a> {
         };
         // The user - used for first-usage tracking of any expressions we analyze in a class definition -
         // is the `Idx<Key>` of the class object bound to the class name.
-        let class_object = self.declare_user(Key::Definition(ShortIdentifier::new(class_name)));
+        let class_object =
+            self.declare_current_idx(Key::Definition(ShortIdentifier::new(class_name)));
         (class_object, class_indices)
     }
 
@@ -309,7 +310,7 @@ impl<'a> BindingsBuilder<'a> {
         let decorator_keys = decorators_with_ranges
             .map(|(idx, _)| *idx)
             .into_boxed_slice();
-        self.bind_definition_user(
+        self.bind_definition_current(
             &x.name,
             class_object,
             Binding::ClassDef(class_indices.class_idx, decorator_keys),
@@ -419,7 +420,7 @@ impl<'a> BindingsBuilder<'a> {
     fn synthesize_class_def(
         &mut self,
         class_name: Identifier,
-        class_object: User,
+        class_object: CurrentIdx,
         class_indices: ClassIndices,
         base: Option<Expr>,
         keywords: Box<[(Name, Expr)]>,
@@ -563,7 +564,7 @@ impl<'a> BindingsBuilder<'a> {
                 },
             );
         }
-        self.bind_definition_user(
+        self.bind_definition_current(
             &class_name,
             class_object,
             Binding::ClassDef(class_indices.class_idx, Box::new([])),