pyrefly 0.24.1__tar.gz → 0.24.2__tar.gz

{pyrefly-0.24.1 → pyrefly-0.24.2}/Cargo.lock

@@ -1991,7 +1991,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.24.1"
+version = "0.24.2"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2048,7 +2048,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.24.1"
+version = "0.24.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2057,7 +2057,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.24.1"
+version = "0.24.2"
 dependencies = [
  "anyhow",
  "dupe",
@@ -2079,7 +2079,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.24.1"
+version = "0.24.2"
 dependencies = [
  "anstream",
  "anyhow",

{pyrefly-0.24.1 → pyrefly-0.24.2}/Cargo.toml

@@ -9,7 +9,7 @@ lto = true
 codegen-units = 1
 
 [workspace]
-members = ["pyrefly", "pyrefly_derive", "pyrefly_util"]
+members = ["pyrefly"]
 resolver = "2"
 
 [workspace.package]

{pyrefly-0.24.1 → pyrefly-0.24.2}/PKG-INFO

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

{pyrefly-0.24.1 → pyrefly-0.24.2/crates}/pyrefly_derive/Cargo.toml

@@ -1,8 +1,8 @@
-# @generated by autocargo from //pyrefly/pyrefly_derive:pyrefly_derive
+# @generated by autocargo from //pyrefly/crates/pyrefly_derive:pyrefly_derive
 
 [package]
 name = "pyrefly_derive"
-version = "0.24.1"
+version = "0.24.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.24.1 → pyrefly-0.24.2}/crates/pyrefly_python/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.24.1"
+version = "0.24.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -15,7 +15,7 @@ equivalent = "1.0"
 itertools = "0.14.0"
 lsp-types = "0.94.1"
 parse-display = "0.8.2"
-pyrefly_util = { path = "../../pyrefly_util" }
+pyrefly_util = { path = "../pyrefly_util" }
 regex = "1.11.1"
 ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "9bee8376a17401f9736b45fdefffb62edc2f1668" }
 ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "9bee8376a17401f9736b45fdefffb62edc2f1668" }

{pyrefly-0.24.1 → pyrefly-0.24.2/crates}/pyrefly_util/Cargo.toml

@@ -1,8 +1,8 @@
-# @generated by autocargo from //pyrefly/pyrefly_util:pyrefly_util
+# @generated by autocargo from //pyrefly/crates/pyrefly_util:pyrefly_util
 
 [package]
 name = "pyrefly_util"
-version = "0.24.1"
+version = "0.24.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.24.1"
+version = "0.24.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -36,9 +36,9 @@ num-traits = { version = "0.2.18", default-features = false }
 parse-display = "0.8.2"
 paste = "1.0.14"
 path-absolutize = { version = "3.0", features = ["use_unix_paths_on_wasm"] }
-pyrefly_derive = { path = "../pyrefly_derive" }
+pyrefly_derive = { path = "../crates/pyrefly_derive" }
 pyrefly_python = { path = "../crates/pyrefly_python" }
-pyrefly_util = { path = "../pyrefly_util" }
+pyrefly_util = { path = "../crates/pyrefly_util" }
 regex = "1.11.1"
 regex-syntax = "0.7.5"
 ruff_annotate_snippets = { git = "https://github.com/astral-sh/ruff/", rev = "9bee8376a17401f9736b45fdefffb62edc2f1668" }

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/bin/main.rs

@@ -132,7 +132,7 @@ async fn run_autotype(
     files_to_check: FilteredGlobs,
     config_finder: ConfigFinder,
 ) -> anyhow::Result<CommandExitStatus> {
-    args.run(files_to_check, config_finder, None)
+    args.run(files_to_check, config_finder)
 }
 
 async fn run_check(

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/lib/alt/call.rs

@@ -642,19 +642,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     context,
                 )
             }
-            Target::FunctionOverload(overloads, meta) => self.call_overloads(
-                overloads, meta, None, args, keywords, range, errors, context,
-            ),
-            Target::BoundMethodOverload(obj, overloads, meta) => self.call_overloads(
-                overloads,
-                meta,
-                Some(CallArg::ty(&obj, range)),
-                args,
-                keywords,
-                range,
-                errors,
-                context,
-            ),
+            Target::FunctionOverload(overloads, meta) => {
+                self.call_overloads(
+                    overloads, meta, None, args, keywords, range, errors, context,
+                )
+                .0
+            }
+            Target::BoundMethodOverload(obj, overloads, meta) => {
+                self.call_overloads(
+                    overloads,
+                    meta,
+                    Some(CallArg::ty(&obj, range)),
+                    args,
+                    keywords,
+                    range,
+                    errors,
+                    context,
+                )
+                .0
+            }
             Target::Union(targets) => {
                 let call = CallWithTypes::new();
                 self.unions(targets.into_map(|t| {
@@ -702,7 +708,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    fn call_overloads(
+    /// Calls an overloaded function, returning the return type and the closest matching overload signature.
+    pub fn call_overloads(
         &self,
         overloads: Vec1<Callable>,
         metadata: FuncMetadata,
@@ -712,7 +719,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
-    ) -> Type {
+    ) -> (Type, Callable) {
         // There may be Expr values in self_arg, args and keywords.
         // 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.
@@ -759,7 +766,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // empty, as parameter types from the overload signature may be used as hints when
                 // evaluating arguments, producing arg_errors for some overloads but not others.
                 // See test::overload::test_pass_generic_class_to_overload for an example.
-                return res;
+                return (res, callable.clone());
             }
             let called_overload = CalledOverload {
                 signature: callable.clone(),
@@ -797,7 +804,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             //
             // the call to f should match the first overload, even though `1 + "2"` generates an
             // arg error for both overloads.
-            closest_overload.return_type
+            (closest_overload.return_type, closest_overload.signature)
         } else {
             let mut msg = vec1![
                 format!(
@@ -825,7 +832,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             // there's a high likelihood that the "closest" one by our heuristic isn't the right
             // one, in which case the call errors are just noise.
             errors.add(range, ErrorKind::NoMatchingOverload, context, msg);
-            Type::any_error()
+            (Type::any_error(), closest_overload.signature)
         }
     }
 

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/lib/alt/callable.rs

@@ -424,7 +424,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // so that we can easily peek at and pop from the end.
         let mut rparams = params.items().iter().cloned().rev().collect::<Vec<_>>();
         let mut num_positional_params = 0;
-        let mut num_positional_args = 0;
+        let mut num_extra_positional_args = 0;
         let mut seen_names = SmallMap::new();
         let mut extra_arg_pos = None;
         let mut unpacked_vararg = None;
@@ -453,7 +453,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         for arg in iargs {
             let mut arg_pre = arg.pre_eval(self, arg_errors);
             while arg_pre.step() {
-                num_positional_args += 1;
                 let param = if let Some(p) = rparams.last() {
                     PosParam::new(p)
                 } else if let Some(var) = paramspec {
@@ -521,8 +520,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     ),
                     None => {
                         arg_pre.post_infer(self, arg_errors);
-                        if arg_pre.is_star() {
-                            num_positional_args -= 1;
+                        if !arg_pre.is_star() {
+                            num_extra_positional_args += 1;
                         }
                         if extra_arg_pos.is_none() && !arg_pre.is_star() {
                             extra_arg_pos = Some(arg.range());
@@ -597,20 +596,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             );
         }
         if let Some(arg_range) = extra_arg_pos {
-            let (expected, actual) = if self_arg.is_none() {
-                (
-                    count(num_positional_params as usize, "positional argument"),
-                    num_positional_args.to_string(),
-                )
-            } else if num_positional_params < 1 {
+            let (expected, actual) = if self_arg.is_some() && num_positional_params == 0 {
                 (
                     "0 positional arguments".to_owned(),
-                    format!("{num_positional_args} (including implicit `self`)"),
+                    format!("{num_extra_positional_args} (including implicit `self`)"),
                 )
             } else {
+                let num_positional_params = num_positional_params - (self_arg.is_some() as usize);
                 (
-                    count(num_positional_params as usize - 1, "positional argument"),
-                    (num_positional_args - 1).to_string(),
+                    count(num_positional_params, "positional argument"),
+                    (num_positional_params + num_extra_positional_args).to_string(),
                 )
             };
             error(

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/lib/alt/class/class_field.rs

@@ -16,7 +16,6 @@ use pyrefly_derive::VisitMut;
 use pyrefly_python::dunder;
 use pyrefly_util::owner::Owner;
 use pyrefly_util::prelude::ResultExt;
-use ruff_python_ast::Arguments;
 use ruff_python_ast::Expr;
 use ruff_python_ast::ExprCall;
 use ruff_python_ast::name::Name;
@@ -48,7 +47,6 @@ use crate::types::callable::Required;
 use crate::types::class::Class;
 use crate::types::class::ClassType;
 use crate::types::keywords::DataclassFieldKeywords;
-use crate::types::keywords::TypeMap;
 use crate::types::literal::Lit;
 use crate::types::literal::LitEnum;
 use crate::types::quantified::Quantified;
@@ -260,7 +258,7 @@ impl ClassField {
         let ClassField(ClassFieldInner::Simple { ty, .. }) = self;
         let param_ty = converter_param.unwrap_or(ty);
         let required = match default {
-            true => Required::Optional,
+            true => Required::Optional(None),
             false => Required::Required,
         };
         if kw_only {
@@ -297,7 +295,7 @@ impl ClassField {
             ClassFieldInner::Simple {
                 initialization: ClassFieldInitialization::ClassBody(_),
                 ..
-            } => Required::Optional,
+            } => Required::Optional(None),
             ClassFieldInner::Simple {
                 initialization:
                     ClassFieldInitialization::Method
@@ -957,7 +955,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         node_index: _,
                         range: _,
                         func,
-                        arguments: Arguments { keywords, .. },
+                        arguments,
                     }) = e
                 {
                     // We already type-checked this expression as part of computing the type for the ClassField,
@@ -968,16 +966,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     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 {
-                                map.0.insert(
-                                    name.id.clone(),
-                                    self.expr_infer(&kw.value, &ignore_errors),
-                                );
-                            }
-                        }
-                        let flags = self.dataclass_field_keywords(&map);
+                        let flags =
+                            self.dataclass_field_keywords(&func_ty, arguments, &ignore_errors);
                         ClassFieldInitialization::ClassBody(Some(flags))
                     } else {
                         ClassFieldInitialization::ClassBody(None)

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/lib/alt/class/dataclass.rs

@@ -8,13 +8,18 @@
 use std::sync::Arc;
 
 use pyrefly_python::dunder;
+use pyrefly_util::prelude::SliceExt;
+use ruff_python_ast::Arguments;
 use ruff_python_ast::name::Name;
 use ruff_text_size::TextRange;
 use starlark_map::small_map::SmallMap;
 use starlark_map::small_set::SmallSet;
+use vec1::Vec1;
 
 use crate::alt::answers::LookupAnswer;
 use crate::alt::answers_solver::AnswersSolver;
+use crate::alt::callable::CallArg;
+use crate::alt::callable::CallKeyword;
 use crate::alt::class::class_field::ClassField;
 use crate::alt::class::class_field::DataclassMember;
 use crate::alt::types::class_metadata::ClassMetadata;
@@ -31,6 +36,7 @@ use crate::types::callable::FuncMetadata;
 use crate::types::callable::Function;
 use crate::types::callable::Param;
 use crate::types::callable::ParamList;
+use crate::types::callable::Params;
 use crate::types::callable::Required;
 use crate::types::class::Class;
 use crate::types::class::ClassType;
@@ -189,8 +195,20 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         });
     }
 
-    pub fn dataclass_field_keywords(&self, map: &TypeMap) -> DataclassFieldKeywords {
-        let init = map.get_bool(&DataclassFieldKeywords::INIT, true);
+    pub fn dataclass_field_keywords(
+        &self,
+        func: &Type,
+        args: &Arguments,
+        errors: &ErrorCollector,
+    ) -> DataclassFieldKeywords {
+        let mut map = TypeMap::new();
+        for kw in args.keywords.iter() {
+            if let Some(name) = &kw.arg {
+                map.0
+                    .insert(name.id.clone(), self.expr_infer(&kw.value, errors));
+            }
+        }
+        let mut init = map.get_bool(&DataclassFieldKeywords::INIT);
         let default = [
             &DataclassFieldKeywords::DEFAULT,
             &DataclassFieldKeywords::DEFAULT_FACTORY,
@@ -198,16 +216,29 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         ]
         .iter()
         .any(|k| map.0.contains_key(*k));
-        let kw_only = map
-            .0
-            .get(&DataclassFieldKeywords::KW_ONLY)
-            .and_then(|t| t.as_bool());
-        let alias = map
+        let mut kw_only = map.get_bool(&DataclassFieldKeywords::KW_ONLY);
+        let mut alias = map
             .get_string(&DataclassFieldKeywords::ALIAS)
             .map(Name::new);
-        let converter_param = self.get_converter_param(map);
+        let mut converter_param = map
+            .0
+            .get(&DataclassFieldKeywords::CONVERTER)
+            .map(|converter| self.get_converter_param(converter));
+        // Note that we intentionally don't try to fill in `default`, since we can't distinguish
+        // between a real default and something like `dataclasses.MISSING`.
+        if init.is_none() || kw_only.is_none() || alias.is_none() || converter_param.is_none() {
+            self.fill_in_field_keywords_from_function_signature(
+                func,
+                args,
+                errors,
+                &mut init,
+                &mut kw_only,
+                &mut alias,
+                &mut converter_param,
+            );
+        }
         DataclassFieldKeywords {
-            init,
+            init: init.unwrap_or(true),
             default,
             kw_only,
             alias,
@@ -215,9 +246,90 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    fn get_converter_param(&self, map: &TypeMap) -> Option<Type> {
+    /// Fill in keyword values from the function signature of a dataclass field specifier.
+    fn fill_in_field_keywords_from_function_signature(
+        &self,
+        func: &Type,
+        args: &Arguments,
+        errors: &ErrorCollector,
+        init: &mut Option<bool>,
+        kw_only: &mut Option<bool>,
+        alias: &mut Option<Name>,
+        converter_param: &mut Option<Type>,
+    ) {
+        let sigs = func.callable_signatures();
+        let sig = if sigs.len() == 1 {
+            sigs[0].clone()
+        } else if sigs.len() > 1
+            && let Type::Overload(overload) = func
+        {
+            // Overloaded function. Call it to see which signature is actually used.
+            self.call_overloads(
+                Vec1::try_from_vec(sigs.map(|x| (*x).clone())).unwrap(),
+                (*overload.metadata).clone(),
+                None,
+                &args.args.map(CallArg::expr_maybe_starred),
+                &args.keywords.map(CallKeyword::new),
+                args.range,
+                errors,
+                None,
+            )
+            .1
+        } else {
+            return;
+        };
+        if let Params::List(params) = &sig.params {
+            for param in params.items() {
+                // Look for a parameter that can be called by name, to attempt to read a default value for a keyword argument.
+                let (name, ty, default_ty) = match param {
+                    Param::Pos(name, ty, Required::Required)
+                    | Param::KwOnly(name, ty, Required::Required) => (name, ty, None),
+                    Param::Pos(name, ty, Required::Optional(default))
+                    | Param::KwOnly(name, ty, Required::Optional(default)) => {
+                        (name, ty, default.as_ref())
+                    }
+                    _ => continue,
+                };
+                if name == &DataclassFieldKeywords::INIT {
+                    self.fill_in_literal(init, ty, default_ty, |ty| ty.as_bool());
+                }
+                if name == &DataclassFieldKeywords::KW_ONLY {
+                    self.fill_in_literal(kw_only, ty, default_ty, |ty| ty.as_bool());
+                }
+                if alias.is_none() && name == &DataclassFieldKeywords::ALIAS {
+                    self.fill_in_literal(alias, ty, default_ty, |ty| match ty {
+                        Type::Literal(Lit::Str(s)) => Some(Name::new(s)),
+                        _ => None,
+                    });
+                }
+                if converter_param.is_none() && name == &DataclassFieldKeywords::CONVERTER {
+                    *converter_param = Some(self.get_converter_param(ty));
+                }
+            }
+        }
+    }
+
+    /// Fills in a keyword with a literal value from a parameter type and default, if possible.
+    fn fill_in_literal<T>(
+        &self,
+        keyword: &mut Option<T>,
+        ty: &Type,
+        default: Option<&Type>,
+        type_to_literal: impl Fn(&Type) -> Option<T>,
+    ) {
+        if keyword.is_none() {
+            if let Some(lit) = type_to_literal(ty) {
+                *keyword = Some(lit);
+            } else if let Some(default) = default
+                && let Some(lit) = type_to_literal(default)
+            {
+                *keyword = Some(lit);
+            }
+        }
+    }
+
+    fn get_converter_param(&self, converter: &Type) -> Type {
         let converter = {
-            let converter = map.0.get(&DataclassFieldKeywords::CONVERTER)?;
             if let Type::ClassDef(cls) = converter
                 && let Type::ClassType(instance) = self.instantiate_fresh(cls)
             {
@@ -233,9 +345,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 converter
             }
         };
-        Some(self.distribute_over_union(converter, |ty| {
+        self.distribute_over_union(converter, |ty| {
             ty.callable_first_param().unwrap_or_else(Type::any_implicit)
-        }))
+        })
     }
 
     fn iter_fields(

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/lib/alt/class/typed_dict.rs

@@ -215,7 +215,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 if field.required {
                     Required::Required
                 } else {
-                    Required::Optional
+                    Required::Optional(None)
                 },
             ));
         }
@@ -286,7 +286,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let keyword_params: Vec<_> = self
             .names_to_fields(cls, fields)
             .filter(|(_, field)| !field.is_read_only()) // filter read-only fields
-            .map(|(name, field)| Param::KwOnly(name.clone(), field.ty.clone(), Required::Optional))
+            .map(|(name, field)| {
+                Param::KwOnly(name.clone(), field.ty.clone(), Required::Optional(None))
+            })
             .collect();
 
         let overload_kwargs = OverloadType::Callable(Callable::list(
@@ -331,7 +333,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         Param::PosOnly(
                             Some(DEFAULT_PARAM.clone()),
                             object_ty.clone(),
-                            Required::Optional,
+                            Required::Optional(None),
                         ),
                     ]),
                     field.ty.clone(),
@@ -388,7 +390,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     Param::PosOnly(
                         Some(DEFAULT_PARAM.clone()),
                         object_ty.clone(),
-                        Required::Optional,
+                        Required::Optional(None),
                     ),
                 ]),
                 object_ty.clone(),
@@ -587,7 +589,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     if field.required {
                         Required::Required
                     } else {
-                        Required::Optional
+                        Required::Optional(None)
                     },
                 )
             })

{pyrefly-0.24.1 → pyrefly-0.24.2}/pyrefly/lib/alt/expr.rs

@@ -1015,7 +1015,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     .into_ty()
             }
             Expr::If(x) => {
-                // TODO: Support type narrowing
                 let condition_type = self.expr_infer(&x.test, errors);
                 let body_type = self.expr_infer_type_no_trace(&x.body, hint, errors);
                 let orelse_type = self.expr_infer_type_no_trace(&x.orelse, hint, errors);