pyrefly 0.16.2__tar.gz → 0.16.3__tar.gz

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

@@ -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",
@@ -1388,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]]
@@ -1754,7 +1754,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.16.2"
+version = "0.16.3"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2565,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.2 → pyrefly-0.16.3}/PKG-INFO

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

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.16.2"
+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"] }

{pyrefly-0.16.2 → 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())
+            }
+            (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)
             }
-            Some(base) => 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);
                     }
                 }
             }

{pyrefly-0.16.2 → 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(
@@ -621,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();
@@ -640,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.2 → 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.2 → 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
     }
 

{pyrefly-0.16.2 → pyrefly-0.16.3}/pyrefly/lib/alt/class/class_metadata.rs

@@ -43,7 +43,6 @@ use crate::types::tuple::Tuple;
 use crate::types::types::AnyStyle;
 use crate::types::types::CalleeKind;
 use crate::types::types::TParamInfo;
-use crate::types::types::TParams;
 use crate::types::types::Type;
 use crate::util::prelude::SliceExt;
 
@@ -533,7 +532,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         bases: Vec<BaseClass>,
         legacy: &[Idx<KeyLegacyTypeParam>],
         errors: &ErrorCollector,
-    ) -> TParams {
+    ) -> Vec<TParamInfo> {
         let legacy_tparams = legacy
             .iter()
             .filter_map(|key| self.get_idx(*key).deref().parameter().cloned())
@@ -632,7 +631,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 tparams.insert(p.clone());
             }
         }
-        self.type_params(name.range, tparams.into_iter().collect(), errors)
+
+        tparams.into_iter().collect()
     }
 
     fn calculate_metaclass(

{pyrefly-0.16.2 → pyrefly-0.16.3}/pyrefly/lib/alt/class/classdef.rs

@@ -12,7 +12,6 @@ use ruff_python_ast::Expr;
 use ruff_python_ast::Identifier;
 use ruff_python_ast::StmtClassDef;
 use ruff_python_ast::name::Name;
-use ruff_text_size::TextRange;
 use starlark_map::small_map::SmallMap;
 
 use crate::alt::answers::AnswersSolver;
@@ -29,8 +28,6 @@ use crate::types::class::Class;
 use crate::types::class::ClassDefIndex;
 use crate::types::class::ClassFieldProperties;
 use crate::types::class::ClassType;
-use crate::types::class::TArgs;
-use crate::types::typed_dict::TypedDict;
 use crate::types::types::TParams;
 use crate::types::types::Type;
 use crate::util::prelude::SliceExt;
@@ -65,7 +62,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) -> Class {
         let scoped_tparams = self.scoped_type_params(x.type_params.as_deref(), errors);
         let bases = bases.map(|x| self.base_class_of(x, errors));
-        let tparams = self.class_tparams(&x.name, scoped_tparams, bases, legacy_tparams, errors);
+        let name = &x.name;
+        let tparams_info = self.class_tparams(name, scoped_tparams, bases, legacy_tparams, errors);
+
+        let tparams = self.type_params(name.range, tparams_info, errors);
+
         Class::new(
             def_index,
             x.name.clone(),
@@ -102,116 +103,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.get_enum_from_class(class_type.class_object())
     }
 
-    /// Creates default type arguments for a class, falling back to Any for type parameters without defaults.
-    fn create_default_targs(
-        &self,
-        cls: &Class,
-        // Placeholder for strict mode: we want to force callers to pass a range so
-        // that we don't refactor in a way where none is available, but this is unused
-        // because we do not have a strict mode yet.
-        _range: Option<TextRange>,
-    ) -> TArgs {
-        let tparams = cls.tparams();
-        if tparams.is_empty() {
-            TArgs::default()
-        } else {
-            // TODO(stroxler): We should error here, but the error needs to be
-            // configurable in the long run, and also suppressed in dependencies
-            // no matter what the configuration is.
-            //
-            // Our plumbing isn't ready for that yet, so for now we are silently
-            // using gradual type arguments.
-            TArgs::new(
-                tparams
-                    .iter()
-                    .map(|x| x.quantified.as_gradual_type())
-                    .collect(),
-            )
-        }
-    }
-
-    /// Silently promotes a Class to a ClassType, using default type arguments. It is up to the
-    /// caller to ensure they are not calling this method on a TypedDict class, which should be
-    /// promoted to TypedDict instead of ClassType.
-    pub fn promote_nontypeddict_silently_to_classtype(&self, cls: &Class) -> ClassType {
-        ClassType::new(cls.dupe(), self.create_default_targs(cls, None))
-    }
-
-    fn type_of_instance(&self, cls: &Class, targs: TArgs) -> Type {
-        let metadata = self.get_metadata_for_class(cls);
-        if metadata.is_typed_dict() {
-            Type::TypedDict(TypedDict::new(cls.dupe(), targs))
-        } else {
-            Type::ClassType(ClassType::new(cls.dupe(), targs))
-        }
-    }
-
-    /// Given a class or typed dictionary and some (explicit) type arguments, construct a `Type`
-    /// that represents the type of an instance of the class or typed dictionary with those `targs`.
-    ///
-    /// Note how this differs from `promote` and `instantiate`:
-    /// specialize(list, [int]) == list[int]
-    /// promote(list) == list[Any]
-    /// instantiate(list) == list[T]
-    pub fn specialize(
-        &self,
-        cls: &Class,
-        targs: Vec<Type>,
-        range: TextRange,
-        errors: &ErrorCollector,
-    ) -> Type {
-        let targs = if !targs.is_empty() && self.get_metadata_for_class(cls).has_unknown_tparams() {
-            // Accept any number of arguments (by ignoring them).
-            TArgs::default()
-        } else {
-            self.check_and_create_targs(cls.name(), cls.tparams(), targs, range, errors)
-        };
-        self.type_of_instance(cls, targs)
-    }
-
-    /// Given a class or typed dictionary, create a `Type` that represents to an instance annotated
-    /// with the class or typed dictionary's bare name. This will either have empty type arguments if the
-    /// class or typed dictionary is not generic, or type arguments populated with gradual types if
-    /// it is (e.g. applying an annotation of `list` to a variable means
-    /// `list[Any]`).
-    ///
-    /// We require a range because depending on the configuration we may raise
-    /// a type error when a generic class or typed dictionary is promoted using gradual types.
-    ///
-    /// Note how this differs from `specialize` and `instantiate`:
-    /// specialize(list, [int]) == list[int]
-    /// promote(list) == list[Any]
-    /// instantiate(list) == list[T]
-    pub fn promote(&self, cls: &Class, range: TextRange) -> Type {
-        let targs = self.create_default_targs(cls, Some(range));
-        self.type_of_instance(cls, targs)
-    }
-
-    /// Version of `promote` that does not potentially raise errors.
-    /// Should only be used for unusual scenarios.
-    pub fn promote_silently(&self, cls: &Class) -> Type {
-        let targs = self.create_default_targs(cls, None);
-        self.type_of_instance(cls, targs)
-    }
-
-    /// Given a class or typed dictionary, create a `Type` that represents a generic instance of
-    /// the class or typed dictionary.
-    ///
-    /// Note how this differs from `specialize` and `promote`:
-    /// specialize(list, [int]) == list[int]
-    /// promote(list) == list[Any]
-    /// instantiate(list) == list[T]
-    pub fn instantiate(&self, cls: &Class) -> Type {
-        self.type_of_instance(cls, cls.tparams_as_targs())
-    }
-
-    /// Instantiates a class or typed dictionary with fresh variables for its type parameters.
-    pub fn instantiate_fresh(&self, cls: &Class) -> Type {
-        self.solver()
-            .fresh_quantified(cls.tparams(), self.instantiate(cls), self.uniques)
-            .1
-    }
-
     pub fn unwrap_class_object_silently(&self, ty: &Type) -> Option<Type> {
         match ty {
             Type::ClassDef(c) if c.is_builtin("tuple") => Some(Type::any_tuple()),

{pyrefly-0.16.2 → pyrefly-0.16.3}/pyrefly/lib/alt/class/mod.rs

@@ -14,3 +14,4 @@ pub mod named_tuple;
 pub mod new_type;
 pub mod targs;
 pub mod typed_dict;
+pub mod variance_inference;