pyrefly 0.29.1__tar.gz → 0.29.2__tar.gz

{pyrefly-0.29.1 → pyrefly-0.29.2}/Cargo.lock

@@ -2058,7 +2058,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2106,7 +2106,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_bundled"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "anyhow",
  "starlark_map",
@@ -2116,7 +2116,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_config"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -2149,7 +2149,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2158,7 +2158,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "anyhow",
  "dupe",
@@ -2180,7 +2180,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_types"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "compact_str 0.8.0",
  "dupe",
@@ -2200,7 +2200,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.29.1"
+version = "0.29.2"
 dependencies = [
  "anstream",
  "anyhow",

{pyrefly-0.29.1 → pyrefly-0.29.2}/PKG-INFO

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_bundled/Cargo.toml

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_config/Cargo.toml

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_config/src/config.rs

@@ -375,6 +375,9 @@ impl ConfigFile {
     pub const PYREFLY_FILE_NAME: &str = "pyrefly.toml";
     pub const PYPROJECT_FILE_NAME: &str = "pyproject.toml";
     pub const CONFIG_FILE_NAMES: &[&str] = &[Self::PYREFLY_FILE_NAME, Self::PYPROJECT_FILE_NAME];
+    /// Files that don't contain pyrefly-specific config information but indicate that we're at the
+    /// root of a Python project, which should be added to the search path.
+    pub const ADDITIONAL_ROOT_FILE_NAMES: &[&str] = &["mypy.ini", "pyrightconfig.json"];
 
     /// Writes the configuration to a file in the specified directory.
     /// TODO(connernilsen) relative these paths to the config file's directory
@@ -387,9 +390,6 @@ impl ConfigFile {
 
         Ok(())
     }
-    /// Files that don't contain pyrefly-specific config information but indicate that we're at the
-    /// root of a Python project, which should be added to the search path.
-    pub const ADDITIONAL_ROOT_FILE_NAMES: &[&str] = &["setup.py", "mypy.ini", "pyrightconfig.json"];
 
     pub fn default_project_includes() -> Globs {
         Globs::new(vec!["**/*".to_owned()]).unwrap_or_else(|_| Globs::empty())
@@ -446,7 +446,7 @@ impl ConfigFile {
     }
 
     /// Gets the full, ordered path used for import lookup. Used for pretty-printing.
-    pub fn structured_import_lookup_path(&self) -> Vec<ImportLookupPathPart> {
+    pub fn structured_import_lookup_path(&self) -> Vec<ImportLookupPathPart<'_>> {
         let mut result = vec![
             ImportLookupPathPart::SearchPathFromArgs(&self.search_path_from_args),
             ImportLookupPathPart::SearchPathFromFile(&self.search_path_from_file),
@@ -534,7 +534,7 @@ impl ConfigFile {
                 self.root.permissive_ignores.unwrap())
     }
 
-    pub fn get_error_config(&self, path: &Path) -> ErrorConfig {
+    pub fn get_error_config(&self, path: &Path) -> ErrorConfig<'_> {
         ErrorConfig::new(
             self.errors(path),
             self.ignore_errors_in_generated_code(path),
@@ -1358,16 +1358,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_setup_py_search_path() {
-        let root = TempDir::new().unwrap();
-        let config = create_empty_file_and_parse_config(&root, "setup.py");
-        assert_eq!(
-            config.search_path().cloned().collect::<Vec<_>>(),
-            vec![root.path().to_path_buf()]
-        );
-    }
-
     #[test]
     fn test_mypy_config_search_path() {
         let root = TempDir::new().unwrap();

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_config/src/error.rs

@@ -36,7 +36,7 @@ impl ErrorDisplayConfig {
             .unwrap_or_else(|| kind.default_severity())
     }
 
-    pub(crate) fn set_error_severity(&mut self, kind: ErrorKind, severity: Severity) {
+    pub fn set_error_severity(&mut self, kind: ErrorKind, severity: Severity) {
         self.0.insert(kind, severity);
     }
 }

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_config/src/error_kind.rs

@@ -264,6 +264,7 @@ impl ErrorKind {
             ErrorKind::RevealType => Severity::Info,
             ErrorKind::Deprecated => Severity::Warn,
             ErrorKind::RedundantCast => Severity::Warn,
+            ErrorKind::ImplicitlyDefinedAttribute => Severity::Ignore,
             _ => Severity::Error,
         }
     }

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_derive/Cargo.toml

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_python/Cargo.toml

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/Cargo.toml

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/src/callable.rs

@@ -52,7 +52,7 @@ impl ParamList {
     }
 
     /// Prepend some required position-only parameters.
-    pub fn prepend_types(&self, pre: &[Type]) -> Cow<ParamList> {
+    pub fn prepend_types(&self, pre: &[Type]) -> Cow<'_, ParamList> {
         if pre.is_empty() {
             Cow::Borrowed(self)
         } else {
@@ -153,8 +153,10 @@ impl ParamList {
         self.0.is_empty()
     }
 
-    pub fn tail(&self) -> ParamList {
-        Self(self.0[1..].to_vec())
+    pub fn split_first(&self) -> Option<(&Type, ParamList)> {
+        self.0
+            .split_first()
+            .map(|(first, rest)| (first.as_type(), ParamList(rest.to_vec())))
     }
 
     /// Type signature that permits everything, namely `*args, **kwargs`.
@@ -392,20 +394,25 @@ impl Callable {
         }
     }
 
-    pub fn drop_first_param(&self) -> Option<Self> {
+    pub fn split_first_param(&self) -> Option<(&Type, Self)> {
         match self {
             Self {
                 params: Params::List(params),
                 ret,
-            } if !params.is_empty() => Some(Self::list(params.tail(), ret.clone())),
+            } => {
+                let (first, rest) = params.split_first()?;
+                Some((first, Self::list(rest, ret.clone())))
+            }
             Self {
                 params: Params::ParamSpec(ts, p),
                 ret,
-            } if !ts.is_empty() => Some(Self::concatenate(
-                ts.iter().skip(1).cloned().collect(),
-                p.clone(),
-                ret.clone(),
-            )),
+            } => {
+                let (first, rest) = ts.split_first()?;
+                Some((
+                    first,
+                    Self::concatenate(rest.iter().cloned().collect(), p.clone(), ret.clone()),
+                ))
+            }
             _ => None,
         }
     }

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/src/class.rs

@@ -163,6 +163,7 @@ impl ClassKind {
             ("cached_property", "cached_property") => Self::Property(name.clone()),
             ("cinder", "cached_property") => Self::Property(name.clone()),
             ("cinder", "async_cached_property") => Self::Property(name.clone()),
+            ("enum", "property") => Self::Property(name.clone()),
             ("enum", "member") => Self::EnumMember,
             ("enum", "nonmember") => Self::EnumNonmember,
             ("dataclasses", "Field") => Self::DataclassField,
@@ -333,7 +334,7 @@ impl ClassType {
         Self(self.0.dupe(), self.1.substitute_with(substitution))
     }
 
-    pub fn substitution(&self) -> Substitution {
+    pub fn substitution(&self) -> Substitution<'_> {
         self.targs().substitution()
     }
 

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/src/display.rs

@@ -22,6 +22,7 @@ use starlark_map::smallmap;
 
 use crate::callable::Function;
 use crate::class::Class;
+use crate::literal::Lit;
 use crate::qname::QName;
 use crate::tuple::Tuple;
 use crate::types::AnyStyle;
@@ -188,6 +189,16 @@ impl<'a> TypeDisplayContext<'a> {
         }
     }
 
+    fn fmt_lit(&self, lit: &Lit, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match lit {
+            Lit::Enum(e) => {
+                self.fmt_qname(e.class.qname(), f)?;
+                write!(f, ".{}", e.member)
+            }
+            _ => write!(f, "{lit}"),
+        }
+    }
+
     fn fmt<'b>(&self, t: &'b Type, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.fmt_helper(t, f, true)
     }
@@ -254,7 +265,11 @@ impl<'a> TypeDisplayContext<'a> {
             }
 
             // Other things
-            Type::Literal(lit) => write!(f, "Literal[{lit}]"),
+            Type::Literal(lit) => {
+                write!(f, "Literal[")?;
+                self.fmt_lit(lit, f)?;
+                write!(f, "]")
+            }
             Type::LiteralString => write!(f, "LiteralString"),
             Type::Callable(box c)
             | Type::Function(box Function {
@@ -446,6 +461,7 @@ pub mod tests {
     use crate::class::ClassDefIndex;
     use crate::class::ClassType;
     use crate::literal::Lit;
+    use crate::literal::LitEnum;
     use crate::quantified::Quantified;
     use crate::quantified::QuantifiedKind;
     use crate::tuple::Tuple;
@@ -685,11 +701,26 @@ pub mod tests {
 
     #[test]
     fn test_display_literal() {
+        // Simple literals
         assert_eq!(Type::Literal(Lit::Bool(true)).to_string(), "Literal[True]");
         assert_eq!(
             Type::Literal(Lit::Bool(false)).to_string(),
             "Literal[False]"
         );
+
+        // Enum literals (not all of these types make sense, we're only providing what's relevant)
+        let my_enum = ClassType::new(fake_class("MyEnum", "mod.ule", 5), TArgs::default());
+        let t = Type::Literal(Lit::Enum(Box::new(LitEnum {
+            class: my_enum,
+            member: Name::new_static("X"),
+            ty: Type::any_implicit(),
+        })));
+
+        let mut ctx = TypeDisplayContext::new(&[&t]);
+        assert_eq!(ctx.display(&t).to_string(), "Literal[MyEnum.X]");
+
+        ctx.always_display_module_name();
+        assert_eq!(ctx.display(&t).to_string(), "Literal[mod.ule.MyEnum.X]");
     }
 
     #[test]

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/src/keywords.rs

@@ -126,6 +126,9 @@ pub struct DataclassFieldKeywords {
     pub kw_only: Option<bool>,
     /// Alias that is used in `__init__` rather than the field name. None means no alias
     pub alias: Option<Name>,
+    /// gt and lt specify the range of values that the field can take. None means no constraint
+    pub lt: Option<Type>,
+    pub gt: Option<Type>,
     /// If a converter callable is passed in, its first positional parameter
     pub converter_param: Option<Type>,
 }
@@ -148,6 +151,8 @@ impl DataclassFieldKeywords {
             default: false,
             kw_only: None,
             alias: None,
+            lt: None,
+            gt: None,
             converter_param: None,
         }
     }

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/src/typed_dict.rs

@@ -14,6 +14,7 @@ use crate::annotation::Qualifier;
 use crate::class::Class;
 use crate::qname::QName;
 use crate::read_only::ReadOnlyReason;
+use crate::stdlib::Stdlib;
 use crate::types::Substitution;
 use crate::types::TArgs;
 use crate::types::Type;
@@ -101,6 +102,20 @@ impl ExtraItems {
             }),
         }
     }
+
+    pub fn extra_item(&self, stdlib: &Stdlib) -> ExtraItem {
+        match self {
+            Self::Extra(extra) => extra.clone(),
+            Self::Closed => ExtraItem {
+                ty: Type::never(),
+                read_only: false,
+            },
+            Self::Default => ExtraItem {
+                ty: stdlib.object().clone().to_type(),
+                read_only: true,
+            },
+        }
+    }
 }
 
 #[derive(Clone, Debug, TypeEq, PartialEq, Eq, Hash)]

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_types/src/types.rs

@@ -388,17 +388,6 @@ pub struct BoundMethod {
 }
 
 impl BoundMethod {
-    pub fn drop_self(&self) -> Option<Type> {
-        self.func
-            .clone()
-            .as_type()
-            .drop_first_param_of_unbound_callable()
-    }
-
-    pub fn as_function(self) -> Type {
-        self.func.as_type()
-    }
-
     pub fn with_bound_object(&self, obj: Type) -> Self {
         Self {
             obj,
@@ -931,41 +920,6 @@ impl Type {
         }
     }
 
-    /// If this is an unbound callable (i.e., a callable that is not BoundMethod), strip the first parameter.
-    /// TODO: Does not handle generics.
-    pub fn drop_first_param_of_unbound_callable(&self) -> Option<Type> {
-        match self {
-            Type::Callable(callable) => callable
-                .drop_first_param()
-                .map(|callable| Type::Callable(Box::new(callable))),
-            Type::Function(func) => func.signature.drop_first_param().map(|callable| {
-                Type::Function(Box::new(Function {
-                    signature: callable,
-                    metadata: func.metadata.clone(),
-                }))
-            }),
-            Type::Overload(overload) => overload
-                .signatures
-                .try_mapped_ref(|x| match x {
-                    OverloadType::Function(f) => {
-                        f.signature.drop_first_param().ok_or(()).map(|c| Function {
-                            signature: c,
-                            metadata: f.metadata.clone(),
-                        })
-                    }
-                    _ => Err(()),
-                })
-                .ok()
-                .map(|signatures| {
-                    Type::Overload(Overload {
-                        signatures: signatures.mapped(OverloadType::Function),
-                        metadata: overload.metadata.clone(),
-                    })
-                }),
-            _ => None,
-        }
-    }
-
     pub fn is_none(&self) -> bool {
         matches!(self, Type::None)
     }
@@ -1402,6 +1356,7 @@ impl Type {
             Type::TypeVarTuple(t) => Some(t.qname()),
             Type::ParamSpec(t) => Some(t.qname()),
             Type::SelfType(cls) => Some(cls.qname()),
+            Type::Literal(Lit::Enum(e)) => Some(e.class.qname()),
             _ => None,
         }
     }

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_util/Cargo.toml

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

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_util/src/exclusive_lock.rs

@@ -50,7 +50,7 @@ impl<T: PartialEq> ExclusiveLock<T> {
     /// If the lock is not held, take it and return a guard.
     /// If the lock is held, and the value matches, wait for the lock to be released then return None.
     /// If the lock is held, and the value does not match, return None immediately.
-    pub fn lock(&self, value: T) -> Option<ExclusiveLockGuard<T>> {
+    pub fn lock(&self, value: T) -> Option<ExclusiveLockGuard<'_, T>> {
         let mut exclusive = self.exclusive.lock();
         match &*exclusive {
             None => {

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_util/src/globs.rs

@@ -191,16 +191,30 @@ impl Glob {
         Ok(())
     }
 
-    fn resolve_pattern(pattern: &str, filter: &GlobFilter) -> anyhow::Result<Vec<PathBuf>> {
+    fn resolve_pattern_with_limit(
+        pattern: &str,
+        filter: &GlobFilter,
+        limit: Option<usize>,
+    ) -> anyhow::Result<Vec<PathBuf>> {
         let mut result = Vec::new();
         let paths = glob::glob(pattern)?;
-        for path in paths {
+        for (count, path) in paths.enumerate() {
+            if let Some(limit) = limit
+                && count >= limit
+            {
+                break;
+            }
             let path = path?;
             Self::resolve_path(path, &mut result, filter)?;
         }
         Ok(result)
     }
 
+    #[cfg(test)]
+    fn resolve_pattern(pattern: &str, filter: &GlobFilter) -> anyhow::Result<Vec<PathBuf>> {
+        Self::resolve_pattern_with_limit(pattern, filter, None)
+    }
+
     /// Returns true if the given file matches any of the contained globs.
     /// We always attempt to append `**` in case
     /// the pattern is meant to be a directory wildcard.
@@ -288,7 +302,7 @@ impl PartialEq for Glob {
 }
 
 impl Glob {
-    fn files(&self, filter: &GlobFilter) -> anyhow::Result<Vec<PathBuf>> {
+    fn files(&self, filter: &GlobFilter, limit: Option<usize>) -> anyhow::Result<Vec<PathBuf>> {
         let pattern = &self.0;
         if filter.is_excluded(self.as_path()) {
             return Err(anyhow::anyhow!(
@@ -298,7 +312,7 @@ impl Glob {
             ));
         }
         let pattern_str = pattern.as_str().to_owned();
-        let result = Self::resolve_pattern(&pattern_str, filter)
+        let result = Self::resolve_pattern_with_limit(&pattern_str, filter, limit)
             .with_context(|| format!("When resolving pattern `{pattern_str}`"))?;
         Ok(result)
     }
@@ -431,8 +445,13 @@ impl Globs {
         Ok(result)
     }
 
-    fn filtered_files(&self, filter: &GlobFilter) -> anyhow::Result<Vec<PathBuf>> {
-        if USE_EDEN {
+    fn filtered_files(
+        &self,
+        filter: &GlobFilter,
+        limit: Option<usize>,
+    ) -> anyhow::Result<Vec<PathBuf>> {
+        // Eden glob returns all results. It doesn't provide an API to limit the number of results.
+        if USE_EDEN && limit.is_none() {
             match self.files_eden(filter) {
                 Ok(files) if files.is_empty() => {
                     return Err(anyhow::anyhow!(
@@ -447,7 +466,17 @@ impl Globs {
 
         let mut result = SmallSet::new();
         for pattern in &self.0 {
-            result.extend(pattern.files(filter)?);
+            let remaining_limit = if let Some(limit) = limit {
+                if limit > result.len() {
+                    Some(limit - result.len())
+                } else {
+                    break;
+                }
+            } else {
+                None
+            };
+            let files = pattern.files(filter, remaining_limit)?;
+            result.extend(files);
         }
         if result.is_empty() {
             if self.0.is_empty() {
@@ -474,7 +503,14 @@ impl Globs {
     }
 
     pub fn files(&self) -> anyhow::Result<Vec<PathBuf>> {
-        self.filtered_files(&GlobFilter::empty())
+        self.filtered_files(&GlobFilter::empty(), None)
+    }
+
+    /// Same as `files`, but with an upper limit on the number of files returned.
+    /// This is useful for indexing of workspaces, where we don't want to index too many files
+    /// when the user decides to open VSCode at the root of the filesystem.
+    pub fn files_with_limit(&self, limit: usize) -> anyhow::Result<Vec<PathBuf>> {
+        self.filtered_files(&GlobFilter::empty(), Some(limit))
     }
 
     pub fn covers(&self, path: &Path) -> bool {
@@ -622,7 +658,7 @@ impl FilteredGlobs {
     }
 
     pub fn files(&self) -> anyhow::Result<Vec<PathBuf>> {
-        self.includes.filtered_files(&self.filter)
+        self.includes.filtered_files(&self.filter, None)
     }
 
     pub fn covers(&self, path: &Path) -> bool {
@@ -1139,7 +1175,7 @@ mod tests {
         let assert_empty_glob = |pattern_str: &str, description: &str| {
             let found_files = Glob::new_with_root(root, pattern_str.to_owned())
                 .unwrap()
-                .files(&GlobFilter::empty())
+                .files(&GlobFilter::empty(), None)
                 .unwrap_or_else(|_| Vec::new());
             assert!(
                 found_files.is_empty(),
@@ -1157,7 +1193,7 @@ mod tests {
         // Verify that normal files are still found
         let normal_files = Glob::new_with_root(root, "**/*.py".to_owned())
             .unwrap()
-            .files(&GlobFilter::empty())
+            .files(&GlobFilter::empty(), None)
             .unwrap();
         assert!(
             !normal_files.is_empty(),
@@ -1206,20 +1242,26 @@ mod tests {
         assert!(
             Glob::new(pattern.clone())
                 .unwrap()
-                .files(&GlobFilter::new(
-                    Globs::new(vec![root.join("**").to_string_lossy().to_string()]).unwrap(),
+                .files(
+                    &GlobFilter::new(
+                        Globs::new(vec![root.join("**").to_string_lossy().to_string()]).unwrap(),
+                        None
+                    ),
                     None
-                ))
+                )
                 .is_err()
         );
         // double check that <path>/** will also match <path>
         assert!(
             Globs::new(vec![root.to_string_lossy().to_string()])
                 .unwrap()
-                .filtered_files(&GlobFilter::new(
-                    Globs::new(vec![root.join("**").to_string_lossy().to_string()]).unwrap(),
+                .filtered_files(
+                    &GlobFilter::new(
+                        Globs::new(vec![root.join("**").to_string_lossy().to_string()]).unwrap(),
+                        None
+                    ),
                     None
-                ))
+                )
                 .is_err()
         );
         assert_eq!(

{pyrefly-0.29.1 → pyrefly-0.29.2}/crates/pyrefly_util/src/ruff_visitors.rs

@@ -20,6 +20,7 @@ use ruff_python_ast::TStringPart;
 use ruff_python_ast::TypeParams;
 use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
 use ruff_python_ast::visitor::source_order::walk_arguments;
+use ruff_python_ast::visitor::source_order::walk_decorator;
 use ruff_python_ast::visitor::source_order::walk_parameters;
 use ruff_python_ast::visitor::source_order::walk_pattern;
 use ruff_python_ast::visitor::source_order::walk_stmt;
@@ -373,7 +374,13 @@ impl Visit for Pattern {
 
 impl Visit<Expr> for Decorator {
     fn recurse<'a>(&'a self, f: &mut dyn FnMut(&'a Expr)) {
-        self.expression.recurse(f);
+        struct X<T>(T);
+        impl<'a, T: FnMut(&'a Expr)> SourceOrderVisitor<'a> for X<T> {
+            fn visit_expr(&mut self, x: &'a Expr) {
+                self.0(x);
+            }
+        }
+        walk_decorator(&mut X(f), self);
     }
 }