pyrefly 0.14.1__tar.gz → 0.15.1__tar.gz

{pyrefly-0.14.1 → pyrefly-0.15.1}/PKG-INFO

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

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/Cargo.lock

@@ -325,9 +325,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.37"
+version = "4.5.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
+checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -335,9 +335,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.37"
+version = "4.5.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
+checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1740,7 +1740,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.14.1"
+version = "0.15.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2376,9 +2376,9 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.1"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
  "fastrand",
  "getrandom 0.3.3",

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.14.1"
+version = "0.15.1"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyrefly"
@@ -24,7 +24,7 @@ argfile = "0.1.6"
 base64 = { version = "0.21", features = ["alloc"] }
 blake3 = { version = "=1.5.5", features = ["mmap", "rayon", "traits-preview"] }
 bstr = { version = "1.10.0", features = ["serde", "std", "unicode"] }
-clap = { version = "4.5.30", features = ["derive", "env", "string", "unicode", "wrap_help"] }
+clap = { version = "4.5.38", features = ["derive", "env", "string", "unicode", "wrap_help"] }
 configparser = { version = "3.0.3", features = ["indexmap"] }
 const-str = "0.4.3"
 convert_case = "0.6"
@@ -62,7 +62,7 @@ static_assertions = "1.1.0"
 static_interner = "0.1.1"
 tar = "0.4.44"
 thiserror = "2"
-tokio = { version = "1.44.2", features = ["macros", "rt"] }
+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"] }

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/bin/main.rs

@@ -154,7 +154,7 @@ fn get_explicit_config(
     let (file_config, parse_errors) = ConfigFile::from_file(path);
     let (config, validation_errors) = args.override_config(file_config);
     (
-        ArcId::new(config),
+        config,
         parse_errors.into_iter().chain(validation_errors).collect(),
     )
 }
@@ -177,7 +177,7 @@ fn get_globs_and_config_for_project(
                 ));
                 // Since this is a config we generated, these are likely internal errors.
                 debug_log(errors);
-                ArcId::new(config)
+                config
             });
             (config, config_finder.errors())
         }
@@ -186,6 +186,12 @@ fn get_globs_and_config_for_project(
         ConfigSource::File(path) => {
             info!("Checking project configured at `{}`", path.display());
         }
+        ConfigSource::Marker(path) => {
+            info!(
+                "Found `{}` marking project root, checking root directory with default configuration",
+                path.display(),
+            );
+        }
         ConfigSource::Synthetic => {
             info!("Checking current directory with default configuration");
         }
@@ -196,12 +202,8 @@ fn get_globs_and_config_for_project(
     config_finder.add_errors(errors);
 
     debug!("Config is: {}", config);
-    let project_excludes = project_excludes.unwrap_or_else(|| config.project_excludes.clone());
 
-    Ok((
-        FilteredGlobs::new(config.project_includes.clone(), project_excludes),
-        config_finder,
-    ))
+    Ok((config.get_filtered_globs(project_excludes), config_finder))
 }
 
 /// Get inputs for a per-file check. If an explicit config is passed in, we use it; otherwise, we
@@ -300,8 +302,14 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
                     ConfigSource::Synthetic => {
                         println!("Default configuration");
                     }
+                    ConfigSource::Marker(path) => {
+                        println!(
+                            "Default configuration for project root marked by `{}`",
+                            path.display()
+                        );
+                    }
                     ConfigSource::File(path) => {
-                        println!("Configuration at {path:?}");
+                        println!("Configuration at `{}`", path.display());
                     }
                 }
                 println!("  Covered files:");
@@ -313,9 +321,11 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
                         break;
                     }
                 }
-                println!("  Search path: {:?}", config.search_path);
-                println!("  Fallback search path: {:?}", config.fallback_search_path);
-                println!("  Site package path: {:?}", config.site_package_path());
+                for path_part in config.structured_import_lookup_path() {
+                    if !path_part.is_empty() {
+                        println!("  {path_part}");
+                    }
+                }
             }
             Ok(CommandExitStatus::Success)
         }

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/alt/answers.rs

@@ -463,11 +463,15 @@ impl Answers {
                     }
                 };
                 let reference_range = bindings.idx_to_key(idx).range();
-                index
-                    .externally_defined_variable_references
-                    .entry((imported_module_name, imported_name))
-                    .or_default()
-                    .push(reference_range);
+                // Sanity check: the reference should have the same text as the definition.
+                // This check helps to filter out synthetic bindings.
+                if bindings.module_info().code_at(reference_range) == imported_name.as_str() {
+                    index
+                        .externally_defined_variable_references
+                        .entry((imported_module_name, imported_name))
+                        .or_default()
+                        .push(reference_range);
+                }
             }
         }
 

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/alt/class/class_field.rs

@@ -10,6 +10,7 @@ use std::fmt::Display;
 use std::sync::Arc;
 
 use dupe::Dupe;
+use itertools::Itertools;
 use pyrefly_derive::TypeEq;
 use pyrefly_derive::VisitMut;
 use ruff_python_ast::Arguments;
@@ -527,7 +528,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self,
         name: &Name,
         value: &ExprOrBinding,
-        annotation: Option<&Annotation>,
+        // Type annotation that appears directly on the field declaration (vs. one inherited from a parent)
+        direct_annotation: Option<&Annotation>,
         initial_value: &ClassFieldInitialValue,
         class: &Class,
         is_function_without_return_annotation: bool,
@@ -538,9 +540,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // then we can avoid a bunch of work with checking for override errors.
         let mut name_might_exist_in_inherited = true;
 
-        let value_ty = match value {
+        let (value_ty, inherited_annotation) = match value {
             ExprOrBinding::Expr(e) => {
-                let inherited_annot = if annotation.is_some() {
+                let inherited_annot = if direct_annotation.is_some() {
                     None
                 } else {
                     let (found_field, annotation) = self.get_inherited_annotation(class, name);
@@ -549,7 +551,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     }
                     annotation
                 };
-                let mut ty = if let Some(annot) = inherited_annot {
+                let mut ty = if let Some(annot) = &inherited_annot {
                     let ctx: &dyn Fn() -> TypeCheckContext =
                         &|| TypeCheckContext::of_kind(TypeCheckKind::Attribute(name.clone()));
                     let hint = Some((annot.get_type(), ctx));
@@ -558,11 +560,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     self.expr_infer(e, errors)
                 };
                 self.expand_type_mut(&mut ty);
-                ty
-            }
-            ExprOrBinding::Binding(b) => {
-                Arc::unwrap_or_clone(self.solve_binding(b, errors)).into_ty()
+                (ty, inherited_annot)
             }
+            ExprOrBinding::Binding(b) => (
+                Arc::unwrap_or_clone(self.solve_binding(b, errors)).into_ty(),
+                None,
+            ),
         };
         let metadata = self.get_metadata_for_class(class);
         let magically_initialized = {
@@ -570,7 +573,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             // See https://github.com/python/typeshed/pull/13875 for reasoning.
             class.module_info().path().is_interface()
             // We consider fields to be always-initialized if it's annotated explicitly with `ClassVar`.
-            || annotation
+            || direct_annotation
                 .as_ref()
                 .is_some_and(|annot| annot.has_qualifier(&Qualifier::ClassVar))
         };
@@ -596,7 +599,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 .is_some_and(|m| m.elements.contains(name))
         {
             for q in &[Qualifier::Final, Qualifier::ClassVar] {
-                if annotation.is_some_and(|ann| ann.has_qualifier(q)) {
+                if direct_annotation.is_some_and(|ann| ann.has_qualifier(q)) {
                     self.error(
                         errors,
                         range,
@@ -616,7 +619,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Qualifier::NotRequired,
                 Qualifier::ReadOnly,
             ] {
-                if annotation.is_some_and(|ann| ann.has_qualifier(q)) {
+                if direct_annotation.is_some_and(|ann| ann.has_qualifier(q)) {
                     self.error(
                         errors,
                         range,
@@ -631,6 +634,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // Determine whether this is an explicit `@override`.
         let is_override = value_ty.is_override();
 
+        let annotation = direct_annotation.or(inherited_annotation.as_ref());
+
         // Promote literals. The check on `annotation` is an optimization, it does not (currently) affect semantics.
         // TODO(stroxler): if we see a read-only `Qualifier` like `Final`, it is sound to preserve literals.
         let value_ty = if annotation.is_none_or(|a| a.ty.is_none()) && value_ty.is_literal() {
@@ -669,10 +674,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // TODO(stroxler, yangdanny): We currently operate on promoted types, which means we do not infer `Literal[...]`
         // types for the `.value` / `._value_` attributes of literals. This is permitted in the spec although not optimal
         // for most cases; we are handling it this way in part because generic enum behavior is not yet well-specified.
+        //
+        // We currently skip the check for `_value_` if the class defines `__new__`, since that can
+        // change the value of the enum member. https://docs.python.org/3/howto/enum.html#when-to-use-new-vs-init
         let ty = if let Some(enum_) = metadata.enum_metadata()
             && self.is_valid_enum_member(name, &ty, &initialization)
         {
-            if annotation.is_some() {
+            if direct_annotation.is_some() {
                 self.error(
                     errors, range,ErrorKind::InvalidAnnotation, None,
                     format!("Enum member `{}` may not be annotated directly. Instead, annotate the _value_ attribute.", name),
@@ -680,6 +688,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
             if enum_.has_value
                 && let Some(enum_value_ty) = self.type_of_enum_value(enum_)
+                && !class.fields().contains(&dunder::NEW)
                 && !self.matches_enum_value_annotation(&ty, &enum_value_ty)
             {
                 self.error(
@@ -731,7 +740,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // Create the resulting field and check for override inconsistencies before returning
         let class_field = ClassField::new(
             ty,
-            annotation.cloned(),
+            direct_annotation.cloned(),
             initialization,
             readonly,
             descriptor_getter,

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/alt/function.rs

@@ -306,12 +306,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             let ty = match self.bindings().get_function_param(&x.name) {
                 Either::Left(idx) => {
                     let annot = self.get_idx(idx);
-                    let ty = annot.annotation.get_type().clone();
-                    if annot.annotation.is_unpacked() {
-                        Type::Unpack(Box::new(ty))
-                    } else {
-                        ty
-                    }
+                    annot.annotation.get_type().clone()
                 }
                 Either::Right(var) => self.solver().force_var(var),
             };

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/alt/solve.rs

@@ -295,26 +295,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     );
                     None
                 }
-                Some(Qualifier::Unpack)
+                Some(Qualifier::TypeAlias)
                     if !matches!(
                         type_form_context,
-                        TypeFormContext::ParameterArgsAnnotation
-                            | TypeFormContext::ParameterKwargsAnnotation,
+                        TypeFormContext::VarAnnotation(_) | TypeFormContext::ClassVarAnnotation
                     ) =>
-                {
-                    self.error(
-                        errors,
-                        x.range(),
-                        ErrorKind::InvalidAnnotation,
-                        None,
-                        "Unpack is not allowed in this context.".to_owned(),
-                    );
-                    // We return the qualifier so that it's consumed and we don't emit a
-                    // duplicate error in the fallback logic
-                    qualifier
-                }
-                Some(Qualifier::TypeAlias)
-                    if !matches!(type_form_context, TypeFormContext::VarAnnotation(_)) =>
                 {
                     self.error(
                         errors,
@@ -762,43 +747,39 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if !Self::is_valid_annotation(expr, errors) {
             return Type::any_error();
         }
-        if matches!(
-            style,
-            TypeAliasStyle::Scoped | TypeAliasStyle::LegacyExplicit
-        ) {
-            let untyped = self.untype_opt(ty.clone(), range);
-            if let Some(ty) = untyped {
-                self.validate_type_form(ty, range, TypeFormContext::TypeAlias, errors);
-            } else {
-                self.error(
-                    errors,
-                    range,
-                    ErrorKind::TypeAliasError,
-                    None,
-                    format!("Expected `{name}` to be a type alias, got {ty}"),
-                );
-                return Type::any_error();
-            }
-        }
-        let mut ty = match &ty {
-            Type::ClassDef(cls) => Type::type_form(self.promote(cls, range)),
-            t => t.clone(),
+        let untyped = self.untype_opt(ty.clone(), range);
+        let mut ty = if let Type::ClassDef(cls) = ty {
+            // TODO: should we be promoting this or making a Forall type?
+            self.promote(&cls, range)
+        } else if let Some(untyped) = untyped {
+            let validated =
+                self.validate_type_form(untyped, range, TypeFormContext::TypeAlias, errors);
+            if validated.is_error() {
+                return validated;
+            }
+            validated
+        } else {
+            self.error(
+                errors,
+                range,
+                ErrorKind::TypeAliasError,
+                None,
+                format!("Expected `{name}` to be a type alias, got {ty}"),
+            );
+            return Type::any_error();
         };
         let mut seen_type_vars = SmallMap::new();
         let mut seen_type_var_tuples = SmallMap::new();
         let mut seen_param_specs = SmallMap::new();
         let mut tparams = Vec::new();
-        match ty {
-            Type::Type(ref mut t) => self.tvars_to_tparams_for_type_alias(
-                t,
-                &mut seen_type_vars,
-                &mut seen_type_var_tuples,
-                &mut seen_param_specs,
-                &mut tparams,
-            ),
-            _ => {}
-        }
-        let ta = TypeAlias::new(name.clone(), ty, style);
+        self.tvars_to_tparams_for_type_alias(
+            &mut ty,
+            &mut seen_type_vars,
+            &mut seen_type_var_tuples,
+            &mut seen_param_specs,
+            &mut tparams,
+        );
+        let ta = TypeAlias::new(name.clone(), Type::type_form(ty), style);
         Forallable::TypeAlias(ta).forall(self.type_params(range, tparams, errors))
     }
 
@@ -1143,26 +1124,30 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 self.check_is_exception(exc, exc.range(), false, errors);
                 self.check_is_exception(cause, cause.range(), true, errors);
             }
-            BindingExpect::Eq(k1, k2, name) => {
-                let ann1 = self.get_idx(*k1);
-                let ann2 = self.get_idx(*k2);
-                if let Some(t1) = ann1.ty(self.stdlib)
-                    && let Some(t2) = ann2.ty(self.stdlib)
-                    && t1 != t2
+            BindingExpect::Redefinition {
+                new,
+                existing,
+                name,
+            } => {
+                let ann_new = self.get_idx(*new);
+                let ann_existing = self.get_idx(*existing);
+                if let Some(t_new) = ann_new.ty(self.stdlib)
+                    && let Some(t_existing) = ann_existing.ty(self.stdlib)
+                    && t_new != t_existing
                 {
-                    let t1 = self.for_display(t1.clone());
-                    let t2 = self.for_display(t2.clone());
-                    let ctx = TypeDisplayContext::new(&[&t1, &t2]);
+                    let t_new = self.for_display(t_new.clone());
+                    let t_existing = self.for_display(t_existing.clone());
+                    let ctx = TypeDisplayContext::new(&[&t_new, &t_existing]);
                     self.error(
                         errors,
-                        self.bindings().idx_to_key(*k1).range(),
+                        self.bindings().idx_to_key(*new).range(),
                         ErrorKind::AnnotationMismatch,
                         None,
                         format!(
-                            "Inconsistent type annotations for {}: {}, {}",
+                            "`{}` cannot be annotated with `{}`, it is already defined with type `{}`",
                             name,
-                            ctx.display(&t1),
-                            ctx.display(&t2),
+                            ctx.display(&t_new),
+                            ctx.display(&t_existing),
                         ),
                     );
                 }
@@ -1685,6 +1670,31 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
+    fn may_be_implicit_type_alias(ty: &Type) -> bool {
+        fn check_type_form(ty: &Type, allow_none: bool) -> bool {
+            // TODO(stroxler, rechen): Do we want to include Type::ClassDef(_)
+            // when there is no annotation, so that `mylist = list` is treated
+            // like a value assignment rather than a type alias?
+            match ty {
+                Type::Type(_) => true,
+                Type::None if allow_none => true,
+                Type::Union(members) => {
+                    for member in members {
+                        // `None` can be part of an implicit type alias if it's
+                        // part of a union. In other words, we treat
+                        // `x = T | None` as a type alias, but not `x = None`
+                        if !check_type_form(member, true) {
+                            return false;
+                        }
+                    }
+                    true
+                }
+                _ => false,
+            }
+        }
+        check_type_form(ty, false)
+    }
+
     fn binding_to_type(&self, binding: &Binding, errors: &ErrorCollector) -> Type {
         match binding {
             Binding::Forward(..)
@@ -1840,10 +1850,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     (Some(true), _) => {
                         self.as_type_alias(name, TypeAliasStyle::LegacyExplicit, ty, expr, errors)
                     }
-                    // TODO(stroxler, rechen): Do we want to include Type::ClassDef(_)
-                    // when there is no annotation, so that `mylist = list` is treated
-                    // like a value assignment rather than a type alias?
-                    (None, Type::Type(_)) => {
+                    (None, ty_ref) if Self::may_be_implicit_type_alias(ty_ref) => {
                         self.as_type_alias(name, TypeAliasStyle::LegacyImplicit, ty, expr, errors)
                     }
                     _ => ty,

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/alt/specials.rs

@@ -29,8 +29,17 @@ use crate::types::special_form::SpecialForm;
 use crate::types::tuple::Tuple;
 use crate::types::types::AnyStyle;
 use crate::types::types::Type;
+use crate::util::display::DisplayWithCtx;
 use crate::util::prelude::SliceExt;
 
+fn is_chained_attribute_access(x: &Expr) -> bool {
+    match x {
+        Expr::Name(_) => true,
+        Expr::Attribute(ExprAttribute { value, .. }) => is_chained_attribute_access(value),
+        _ => false,
+    }
+}
+
 impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     fn extra_unpack_error(&self, errors: &ErrorCollector, range: TextRange) -> Type {
         self.error(
@@ -203,10 +212,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
             Expr::Attribute(ExprAttribute {
                 range,
-                value: box value @ Expr::Name(name),
+                value: box value,
                 attr: member_name,
                 ctx: _,
-            }) => {
+            }) if is_chained_attribute_access(value) => {
                 let ty = self.expr_infer(value, errors);
                 match ty {
                     Type::ClassDef(c)
@@ -220,7 +229,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             *range,
                             format!(
                                 "`{}.{}` is not a valid enum member",
-                                name.id, member_name.id
+                                value.display_with(self.module_info()),
+                                member_name.id
                             ),
                             ErrorKind::InvalidLiteral,
                             None,

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/binding/binding.rs

@@ -278,8 +278,13 @@ pub enum BindingExpect {
     UnpackedLength(Idx<Key>, TextRange, SizeExpectation),
     /// An exception and its cause from a raise statement.
     CheckRaisedException(RaisedException),
-    /// An expectation that the types are identical, with an associated name for error messages.
-    Eq(Idx<KeyAnnotation>, Idx<KeyAnnotation>, Name),
+    /// If a name already has an existing definition and we encounter a new definition,
+    /// make sure the annotations are equal, with an associated name for error messages.
+    Redefinition {
+        new: Idx<KeyAnnotation>,
+        existing: Idx<KeyAnnotation>,
+        name: Name,
+    },
     /// `del` statement
     Delete(Box<Expr>),
 }
@@ -313,11 +318,15 @@ impl DisplayWith<Bindings> for BindingExpect {
             Self::CheckRaisedException(RaisedException::WithCause(box (exc, cause))) => {
                 write!(f, "raise {} from {}", m.display(exc), m.display(cause))
             }
-            Self::Eq(k1, k2, name) => write!(
+            Self::Redefinition {
+                new,
+                existing,
+                name,
+            } => write!(
                 f,
                 "{} == {} on {}",
-                ctx.display(*k1),
-                ctx.display(*k2),
+                ctx.display(*new),
+                ctx.display(*existing),
                 name
             ),
         }
@@ -1029,7 +1038,7 @@ impl AnnotationWithTarget {
             AnnotationTarget::ArgsParam(_) => {
                 if let Type::Unpack(box unpacked) = annotation_ty {
                     Some(unpacked.clone())
-                } else if self.annotation.is_unpacked() || matches!(annotation_ty, Type::Args(_)) {
+                } else if matches!(annotation_ty, Type::Args(_) | Type::Unpack(_)) {
                     Some(annotation_ty.clone())
                 } else {
                     Some(Type::Tuple(Tuple::Unbounded(Box::new(
@@ -1040,8 +1049,7 @@ impl AnnotationWithTarget {
             AnnotationTarget::KwargsParam(_) => {
                 if let Type::Unpack(box unpacked) = annotation_ty {
                     Some(unpacked.clone())
-                } else if self.annotation.is_unpacked() || matches!(annotation_ty, Type::Kwargs(_))
-                {
+                } else if matches!(annotation_ty, Type::Kwargs(_) | Type::Unpack(_)) {
                     Some(annotation_ty.clone())
                 } else {
                     Some(

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/binding/class.rs

@@ -41,6 +41,7 @@ use crate::binding::bindings::BindingsBuilder;
 use crate::binding::bindings::LegacyTParamBuilder;
 use crate::binding::scope::FlowStyle;
 use crate::binding::scope::InstanceAttribute;
+use crate::binding::scope::MethodThatSetsAttr;
 use crate::binding::scope::Scope;
 use crate::binding::scope::ScopeKind;
 use crate::error::kind::ErrorKind;
@@ -201,12 +202,15 @@ impl<'a> BindingsBuilder<'a> {
         if let ScopeKind::ClassBody(body) = last_scope.kind {
             for (
                 name,
-                (method_name, defined_in_recognized_method),
+                MethodThatSetsAttr {
+                    method_name,
+                    recognized_attribute_defining_method,
+                },
                 InstanceAttribute(value, annotation, range),
             ) in body.method_defined_attributes()
             {
                 if !fields.contains_key_hashed(name.as_ref()) {
-                    if !defined_in_recognized_method {
+                    if !recognized_attribute_defining_method {
                         self.error(
                         range,
                         format!("Attribute `{}` is implicitly defined by assignment in method `{method_name}`, which is not a constructor", &name),

{pyrefly-0.14.1 → pyrefly-0.15.1}/pyrefly/lib/binding/expr.rs

@@ -497,8 +497,12 @@ impl<'a> BindingsBuilder<'a> {
                 range: _,
                 func,
                 arguments: _,
-            }) if self.as_special_export(func) == Some(SpecialExport::Exit) => {
-                // Control flow doesn't proceed after sys.exit()
+            }) if matches!(
+                self.as_special_export(func),
+                Some(SpecialExport::Exit | SpecialExport::Quit | SpecialExport::OsExit)
+            ) =>
+            {
+                // Control flow doesn't proceed after sys.exit(), exit(), quit(), or os._exit().
                 self.scopes.current_mut().flow.no_next = true;
                 false
             }