pyrefly 0.16.1__tar.gz → 0.16.3__tar.gz

{pyrefly-0.16.1/pyrefly → pyrefly-0.16.3}/Cargo.lock

@@ -140,12 +140,12 @@ dependencies = [
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.7"
+version = "3.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+checksum = "6680de5231bd6ee4c6191b8a1325daa282b415391ec9d3a37bd34f2060dc73fa"
 dependencies = [
  "anstyle",
- "once_cell",
+ "once_cell_polyfill",
  "windows-sys 0.59.0",
 ]
 
@@ -296,9 +296,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.23"
+version = "1.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4ac86a9e5bc1e2b3449ab9d7d3a6a405e3d1bb28d7b9be8614f55846ae3766"
+checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
 dependencies = [
  "jobserver",
  "libc",
@@ -848,8 +848,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1386,13 +1388,13 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1488,6 +1490,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+
 [[package]]
 name = "os_str_bytes"
 version = "6.6.1"
@@ -1746,7 +1754,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.16.1"
+version = "0.16.3"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1818,6 +1826,21 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "pyrefly_wasm"
+version = "0.0.0"
+dependencies = [
+ "dupe",
+ "getrandom 0.2.16",
+ "pyrefly",
+ "serde",
+ "serde-wasm-bindgen",
+ "starlark_map",
+ "tar",
+ "wasm-bindgen",
+ "zstd",
+]
+
 [[package]]
 name = "quickcheck"
 version = "1.0.3"
@@ -2069,9 +2092,9 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
 
 [[package]]
 name = "ryu"
@@ -2109,6 +2132,17 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3b143e2833c57ab9ad3ea280d21fd34e285a42837aeb0ee301f4f41890fa00e"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "serde_bser"
 version = "0.4.0"
@@ -2531,14 +2565,14 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.45.0"
+version = "1.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2513ca694ef9ede0fb23fe71a4ee4107cb102b9dc1930f6d0fd77aae068ae165"
+checksum = "75ef51a33ef1da925cea3e4eb122833cb377c61439ca401b770f54902b806779"
 dependencies = [
  "backtrace",
  "bytes",
  "libc",
- "mio 1.0.3",
+ "mio 1.0.4",
  "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",

pyrefly-0.16.3/Cargo.toml

@@ -0,0 +1,11 @@
+[workspace]
+members = ["pyrefly", "pyrefly_derive"]
+resolver = "2"
+
+[workspace.package]
+license = "MIT"
+repository = "https://github.com/facebook/pyrefly"
+
+[profile.release]
+lto = true
+codegen-units = 1

{pyrefly-0.16.1 → pyrefly-0.16.3}/PKG-INFO

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

{pyrefly-0.16.1 → pyrefly-0.16.3}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.16.1"
+version = "0.16.3"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyrefly"
@@ -34,7 +34,7 @@ crossbeam-channel = "0.5.15"
 dupe = "0.9.1"
 enum-iterator = "1.4.1"
 equivalent = "1.0"
-glob = "0.3"
+glob = "0.3.2"
 human_bytes = "0.4.3"
 indicatif = { version = "0.17.6", features = ["futures", "improved_unicode", "rayon", "tokio"] }
 itertools = "0.14.0"
@@ -68,7 +68,7 @@ thiserror = "2"
 tokio = { version = "1.45.0", features = ["macros", "rt"] }
 toml = "0.8.19"
 tracing = { version = "0.1.41", features = ["attributes", "valuable"] }
-tracing-subscriber = { version = "0.3.18", features = ["chrono", "env-filter", "json", "local-time", "parking_lot", "registry"] }
+tracing-subscriber = { version = "0.3.19", features = ["chrono", "env-filter", "json", "local-time", "parking_lot", "registry"] }
 vec1 = { version = "1", features = ["serde"] }
 walkdir = "2.3"
 yansi = { version = "1.0.0-rc.1", features = ["hyperlink"] }
@@ -92,9 +92,5 @@ zstd = { version = "0.13", features = ["experimental", "zstdmt"] }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 zstd = "0.13"
 
-[profile.release]
-lto = true
-codegen-units = 1
-
 [lints]
 rust = { unexpected_cfgs = { check-cfg = ["cfg(fbcode_build)"], level = "warn" } }

{pyrefly-0.16.1 → pyrefly-0.16.3}/pyrefly/lib/alt/attr.rs

@@ -36,6 +36,7 @@ use crate::types::callable::Param;
 use crate::types::callable::Required;
 use crate::types::class::Class;
 use crate::types::class::ClassType;
+use crate::types::literal::Lit;
 use crate::types::module::Module;
 use crate::types::quantified::Quantified;
 use crate::types::tuple::Tuple;
@@ -1066,11 +1067,27 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     // This function is intended as a low-level building block
     // Unions or intersections should be handled by callers
     fn lookup_attr_no_union(&self, base: &Type, attr_name: &Name) -> LookupResult {
-        match self.as_attribute_base_no_union(base.clone()) {
-            None => {
-                LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone()))
+        match (base, attr_name.as_str()) {
+            (Type::Literal(Lit::Enum(box (_, member, _))), "_name_" | "name") => {
+                LookupResult::found_type(Type::Literal(Lit::Str(member.as_str().into())))
+            }
+            (Type::Literal(Lit::Enum(box (_, _, raw_type))), "_value_" | "value") => {
+                LookupResult::found_type(raw_type.clone())
             }
-            Some(base) => self.lookup_attr_from_base_no_union(base, attr_name),
+            (Type::SelfType(cls) | Type::ClassType(cls), "name")
+                if self.get_metadata_for_class(cls.class_object()).is_enum() =>
+            {
+                self.lookup_attr_no_union(base, &Name::new_static("_name_"))
+            }
+            (Type::SelfType(cls) | Type::ClassType(cls), "value")
+                if self.get_metadata_for_class(cls.class_object()).is_enum() =>
+            {
+                self.lookup_attr_no_union(base, &Name::new_static("_value_"))
+            }
+            _ if let Some(base) = self.as_attribute_base_no_union(base.clone()) => {
+                self.lookup_attr_from_base_no_union(base, attr_name)
+            }
+            _ => LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone())),
         }
     }
 
@@ -1514,30 +1531,21 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
             if include_types {
                 for info in &mut res {
-                    if let Some(definition) = &info.definition {
-                        match definition {
-                            AttrDefinition::FullyResolved(TextRangeWithModuleInfo {
-                                module_info: _,
-                                range,
-                            }) => {
-                                info.ty = match self
-                                    .lookup_attr_from_attribute_base(base.clone(), &info.name)
-                                {
-                                    LookupResult::Found(attr) => self
-                                        .resolve_get_access(
-                                            attr,
-                                            *range,
-                                            &self.error_swallower(),
-                                            None,
-                                        )
-                                        .ok(),
-                                    _ => None,
-                                };
-                            }
-                            AttrDefinition::PartiallyResolvedImportedModuleAttribute {
-                                module_name: _,
-                            } => {}
-                        }
+                    if let Some(definition) = &info.definition
+                        && matches!(definition, AttrDefinition::FullyResolved(..))
+                        && let LookupResult::Found(attr) =
+                            self.lookup_attr_from_attribute_base(base.clone(), &info.name)
+                        && let Ok(ty) = self.resolve_get_access(
+                            attr,
+                            // Important we do not use the resolved TextRange, as it might be in a different module.
+                            // Whereas the empty TextRange is valid for all modules.
+                            TextRange::default(),
+                            &self.error_swallower(),
+                            None,
+                        )
+                        && !ty.is_error()
+                    {
+                        info.ty = Some(ty);
                     }
                 }
             }
@@ -1545,3 +1553,42 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         res
     }
 }
+
+impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
+    // When coercing an instance of condition_type to bool, check that either it does not override
+    // __bool__, or that condition_type.__bool__ is callable.
+    pub fn check_dunder_bool_is_callable(
+        &self,
+        condition_type: &Type,
+        range: TextRange,
+        errors: &ErrorCollector,
+    ) {
+        let cond_bool_ty = self.type_of_magic_dunder_attr(
+            condition_type,
+            &dunder::BOOL,
+            range,
+            errors,
+            None,
+            "__bool__",
+        );
+
+        // test::narrow::test_walrus_value is an example of a valid union type that
+        // as_call_target() does not handle.
+        if let Some(ty) = cond_bool_ty
+            && !matches!(ty, Type::Union(_) | Type::Never(_))
+            && self.as_call_target(ty.clone()).is_none()
+        {
+            self.error(
+                errors,
+                range,
+                ErrorKind::InvalidArgument,
+                None,
+                format!(
+                    "`{}.__bool__` has type `{}`, which is not callable",
+                    self.for_display(condition_type.clone()),
+                    self.for_display(ty.clone()),
+                ),
+            );
+        }
+    }
+}

{pyrefly-0.16.1 → pyrefly-0.16.3}/pyrefly/lib/alt/call.rs

@@ -85,6 +85,13 @@ enum Target {
     Any(AnyStyle),
 }
 
+struct CalledOverload {
+    signature: Callable,
+    arg_errors: ErrorCollector,
+    call_errors: ErrorCollector,
+    return_type: Type,
+}
+
 impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     fn error_call_target(
         &self,
@@ -365,11 +372,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) -> Type {
         // Based on https://typing.readthedocs.io/en/latest/spec/constructors.html.
         let instance_ty = Type::ClassType(cls.clone());
-        if let Some(ret) = self.call_metaclass(&cls, range, args, keywords, errors, context)
-            && !self.is_compatible_constructor_return(&ret, cls.class_object())
-        {
-            // Got something other than an instance of the class under construction.
-            return ret;
+        let mut overall_ret = None;
+        if let Some(ret) = self.call_metaclass(&cls, range, args, keywords, errors, context) {
+            if self.is_compatible_constructor_return(&ret, cls.class_object()) {
+                overall_ret = Some(ret);
+            } else {
+                // Got something other than an instance of the class under construction.
+                return ret;
+            }
         }
         let (overrides_new, dunder_new_has_errors) =
             if let Some(new_method) = self.get_dunder_new(&cls) {
@@ -394,7 +404,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 );
                 let has_errors = !dunder_new_errors.is_empty();
                 errors.extend(dunder_new_errors);
-                if !self.is_compatible_constructor_return(&ret, cls.class_object()) {
+                if self.is_compatible_constructor_return(&ret, cls.class_object()) {
+                    overall_ret = Some(ret);
+                } else {
                     // Got something other than an instance of the class under construction.
                     return ret;
                 }
@@ -426,7 +438,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 errors.extend(dunder_init_errors);
             }
         }
-        cls.to_type()
+        if let Some(mut ret) = overall_ret {
+            ret.subst_self_type_mut(&instance_ty, &|_, _| true);
+            ret
+        } else {
+            instance_ty
+        }
     }
 
     fn construct_typed_dict(
@@ -458,6 +475,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         Type::TypedDict(typed_dict)
     }
 
+    fn first_arg_type(&self, args: &[CallArg], errors: &ErrorCollector) -> Option<Type> {
+        if let Some(first_arg) = args.first() {
+            match first_arg {
+                CallArg::Expr(e) => Some(self.expr_infer(e, errors)),
+                CallArg::Type(t, _) => Some((**t).clone()),
+                CallArg::Star(..) => None,
+            }
+        } else {
+            None
+        }
+    }
+
     pub fn call_infer(
         &self,
         call_target: CallTarget,
@@ -491,6 +520,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         ),
                     );
                 }
+                if cls.has_qname("builtins", "bool") {
+                    match self.first_arg_type(args, errors) {
+                        None => (),
+                        Some(ty) => self.check_dunder_bool_is_callable(&ty, range, errors),
+                    }
+                };
                 self.construct_class(cls, args, keywords, range, errors, context)
             }
             Target::TypedDict(td) => {
@@ -520,14 +555,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // Most instances of typing.Self are replaced in as_call_target, but __new__ is a
                 // staticmethod, so we don't have access to the first argument until we get here.
                 let id = metadata.kind.as_func_id();
-                let first_arg_type = if id.func == dunder::NEW
-                    && let Some(first_arg) = args.first()
-                {
-                    match first_arg {
-                        CallArg::Expr(e) => Some(self.expr_infer(e, errors)),
-                        CallArg::Type(t, _) => Some((**t).clone()),
-                        CallArg::Star(..) => None,
-                    }
+                let first_arg_type = if id.func == dunder::NEW {
+                    self.first_arg_type(args, errors)
                 } else {
                     None
                 };
@@ -609,8 +638,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Type {
-        let mut closest_overload = None;
-        let mut fewest_errors: Option<ErrorCollector> = None;
+        let mut closest_overload: Option<CalledOverload> = None;
         for callable in overloads {
             let arg_errors = self.error_collector();
             let call_errors = self.error_collector();
@@ -628,42 +656,68 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // "No matching overloads" error with the necessary context.
                 None,
             );
-            if call_errors.is_empty() {
-                errors.extend(arg_errors);
+            if arg_errors.is_empty() && call_errors.is_empty() {
+                // It's only safe to return immediately if both arg_errors and call_errors are
+                // 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;
             }
-            match &fewest_errors {
-                Some(errs) if errs.len() <= call_errors.len() => {}
+            let called_overload = CalledOverload {
+                signature: callable,
+                arg_errors,
+                call_errors,
+                return_type: res,
+            };
+            match &closest_overload {
+                Some(overload)
+                    if overload.call_errors.len() <= called_overload.call_errors.len() => {}
                 _ => {
-                    closest_overload = Some(callable);
-                    fewest_errors = Some(call_errors);
+                    closest_overload = Some(called_overload);
                 }
             }
         }
         // We're guaranteed to have at least one overload.
         let closest_overload = closest_overload.unwrap();
-        let fewest_errors = fewest_errors.unwrap();
+        errors.extend(closest_overload.arg_errors);
         let signature = match self_arg {
             Some(_) => closest_overload
+                .signature
                 .drop_first_param()
-                .unwrap_or(closest_overload),
-            None => closest_overload,
+                .unwrap_or(closest_overload.signature),
+            None => closest_overload.signature,
         };
         let signature = self
             .solver()
             .for_display(Type::Callable(Box::new(signature)));
-        self.error(
-            errors,
-            range,
-            ErrorKind::NoMatchingOverload,
-            context,
-            format!(
-                "No matching overload found for function `{}`, reporting errors for closest overload: `{}`",
-                metadata.kind.as_func_id().format(self.module_info().name()), signature,
-            ),
-        );
-        errors.extend(fewest_errors);
-        Type::any_error()
+        if closest_overload.call_errors.is_empty() {
+            // No overload evaluated completely successfully, but we still say we found a match if
+            // there were only arg_errors, since they may be unrelated. For example, in:
+            //
+            //   @overload
+            //   def f(x: int) -> int: ...
+            //   @overload
+            //   def f(x: int, y: str) -> str: ...
+            //
+            //   f(1+"2")
+            //
+            // the call to f should match the first overload, even though `1 + "2"` generates an
+            // arg error for both overloads.
+            closest_overload.return_type
+        } else {
+            self.error(
+                errors,
+                range,
+                ErrorKind::NoMatchingOverload,
+                context,
+                format!(
+                    "No matching overload found for function `{}`, reporting errors for closest overload: `{}`",
+                    metadata.kind.as_func_id().format(self.module_info().name()), signature,
+                ),
+            );
+            errors.extend(closest_overload.call_errors);
+            Type::any_error()
+        }
     }
 
     /// Helper function hide details of call synthesis from the attribute resolution code.

{pyrefly-0.16.1 → pyrefly-0.16.3}/pyrefly/lib/alt/callable.rs

@@ -793,7 +793,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             );
                         }
                     }
-                    Type::Any(_) => {}
+                    Type::Any(_) | Type::Ellipsis => {}
                     _ => {
                         // This could well be our error, but not really sure
                         self.error(

{pyrefly-0.16.1 → pyrefly-0.16.3}/pyrefly/lib/alt/class/class_field.rs

@@ -533,6 +533,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         initial_value: &ClassFieldInitialValue,
         class: &Class,
         is_function_without_return_annotation: bool,
+        implicit_def_method: Option<&Name>,
         range: TextRange,
         errors: &ErrorCollector,
     ) -> ClassField {
@@ -757,6 +758,26 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 errors,
             );
         }
+        if let Some(method_name) = implicit_def_method {
+            let mut defined_in_parent = false;
+            let metadata = self.get_metadata_for_class(class);
+            let parents = metadata.bases_with_metadata();
+            for (parent, _) in parents {
+                if self.get_class_member(parent.class_object(), name).is_some() {
+                    defined_in_parent = true;
+                    break;
+                };
+            }
+            if !defined_in_parent {
+                self.error(
+                errors,
+                range,
+                ErrorKind::ImplicitlyDefinedAttribute,
+                None,
+                format!("Attribute `{}` is implicitly defined by assignment in method `{method_name}`, which is not a constructor", &name),
+            );
+            }
+        }
         class_field
     }