pyrefly 0.28.0__tar.gz → 0.28.1__tar.gz

{pyrefly-0.28.0 → pyrefly-0.28.1}/Cargo.lock

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/PKG-INFO

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_bundled/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_config/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_config/src/error_kind.rs

@@ -146,6 +146,9 @@ pub enum ErrorKind {
     InvalidAnnotation,
     /// Passing an argument that is invalid for reasons besides type.
     InvalidArgument,
+    /// Error caused by incorrect usage of a decorator.
+    /// e.g. using @final on a top-level function
+    InvalidDecorator,
     /// An error caused by incorrect inheritance in a class or type definition.
     /// e.g. a metaclass that is not a subclass of `type`.
     InvalidInheritance,

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_config/src/migration/error_codes.rs

@@ -51,6 +51,8 @@ impl ConfigOptionMigrater for ErrorCodes {
 
 #[cfg(test)]
 mod tests {
+    use configparser::ini::IniDefault;
+
     use super::*;
     use crate::error_kind::ErrorKind;
     use crate::error_kind::Severity;
@@ -113,8 +115,15 @@ mod tests {
 
     #[test]
     fn test_migrate_from_mypy_with_disable_codes() {
-        let mut mypy_cfg = Ini::new();
-        mypy_cfg.set("mypy", "disable_error_code", Some("arg-type".to_owned()));
+        let mut default = IniDefault::default();
+        default.multiline = true;
+        let mut mypy_cfg = Ini::new_from_defaults(default);
+
+        mypy_cfg.set(
+            "mypy",
+            "disable_error_code",
+            Some("arg-type, call-overload".to_owned()),
+        );
 
         let mut pyrefly_cfg = ConfigFile::default();
 
@@ -127,6 +136,10 @@ mod tests {
             errors.severity(ErrorKind::BadArgumentType),
             Severity::Ignore
         );
+        assert_eq!(
+            errors.severity(ErrorKind::NoMatchingOverload),
+            Severity::Ignore
+        );
     }
 
     #[test]

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_config/src/migration/mypy/util.rs

@@ -124,6 +124,26 @@ fn code_to_kind(mut errors: HashMap<String, Severity>) -> Option<ErrorDisplayCon
         map.insert(ErrorKind::BadArgumentType, value);
     }
 
+    if let Some(value) = [errors.remove("assignment")].into_iter().flatten().max() {
+        map.insert(ErrorKind::BadAssignment, value);
+    }
+
+    if let Some(value) = [errors.remove("call-arg")].into_iter().flatten().max() {
+        map.insert(ErrorKind::BadArgumentCount, value);
+    }
+
+    if let Some(value) = [errors.remove("call-overload")].into_iter().flatten().max() {
+        map.insert(ErrorKind::NoMatchingOverload, value);
+    }
+
+    if let Some(value) = [errors.remove("index"), errors.remove("operator")]
+        .into_iter()
+        .flatten()
+        .max()
+    {
+        map.insert(ErrorKind::UnsupportedOperation, value);
+    }
+
     if map.is_empty() {
         None
     } else {

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_derive/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_python/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_python/src/docstring.rs

@@ -51,11 +51,7 @@ impl Docstring {
                 break; // Stop after first match to avoid over-trimming
             }
         }
-        let result = result
-            .replace("\r", "")
-            .replace("\t", "    ")
-            .replace("[", r"\[")
-            .replace("]", r"\]");
+        let result = result.replace("\r", "").replace("\t", "    ");
 
         // Remove the shortest amount of whitespace from the beginning of each line
         let min_indent = result
@@ -103,7 +99,6 @@ mod tests {
             "test docstring"
         );
     }
-
     #[test]
     fn test_clean_removes_multiline_single_quotes() {
         assert_eq!(
@@ -174,9 +169,4 @@ mod tests {
             "hello\nworld\ntest"
         );
     }
-
-    #[test]
-    fn test_brackets() {
-        assert_eq!(Docstring::clean("tuple[test]").as_str(), r"tuple\[test\]");
-    }
 }

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_python/src/lib.rs

@@ -34,3 +34,6 @@ pub mod sys_info;
 
 /// Suffixes of python files that we can be processed.
 pub const PYTHON_EXTENSIONS: &[&str] = &["py", "pyi"];
+
+/// Suffixes of compiled python modules
+pub const COMPILED_FILE_SUFFIXES: &[&str] = &["pyc", "pyx", "pyd"];

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_python/src/module_name.rs

@@ -142,6 +142,10 @@ impl ModuleName {
         Self::from_str("_typeshed._type_checker_internals")
     }
 
+    pub fn pydantic() -> Self {
+        Self::from_str("pydantic.main")
+    }
+
     /// The "unknown" module name, which corresponds to `__unknown__`.
     /// Used for files directly opened or passed on the command line which aren't on the search path.
     pub fn unknown() -> Self {

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_python/src/symbol_kind.rs

@@ -24,6 +24,7 @@ pub enum SymbolKind {
     TypeParameter,
     TypeAlias,
     Function,
+    Method,
     Class,
 }
 
@@ -38,6 +39,7 @@ impl SymbolKind {
             SymbolKind::TypeParameter => lsp_types::SymbolKind::TYPE_PARAMETER,
             SymbolKind::TypeAlias => lsp_types::SymbolKind::INTERFACE,
             SymbolKind::Function => lsp_types::SymbolKind::FUNCTION,
+            SymbolKind::Method => lsp_types::SymbolKind::METHOD,
             SymbolKind::Class => lsp_types::SymbolKind::CLASS,
         }
     }
@@ -52,6 +54,7 @@ impl SymbolKind {
             SymbolKind::TypeParameter => CompletionItemKind::TYPE_PARAMETER,
             SymbolKind::TypeAlias => CompletionItemKind::INTERFACE,
             SymbolKind::Function => CompletionItemKind::FUNCTION,
+            SymbolKind::Method => CompletionItemKind::METHOD,
             SymbolKind::Class => CompletionItemKind::CLASS,
         }
     }
@@ -66,6 +69,7 @@ impl SymbolKind {
             SymbolKind::TypeParameter => "(type parameter)".to_owned(),
             SymbolKind::TypeAlias => "(type alias)".to_owned(),
             SymbolKind::Function => "(function)".to_owned(),
+            SymbolKind::Method => "(method)".to_owned(),
             SymbolKind::Class => "(class)".to_owned(),
         }
     }
@@ -86,6 +90,7 @@ impl SymbolKind {
             SymbolKind::TypeAlias => (SemanticTokenType::INTERFACE, vec![]),
             // todo(samzhou19815): modifier for async
             SymbolKind::Function => (SemanticTokenType::FUNCTION, vec![]),
+            SymbolKind::Method => (SemanticTokenType::METHOD, vec![]),
             SymbolKind::Class => (SemanticTokenType::CLASS, vec![]),
         }
     }

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_types/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_types/src/class.rs

@@ -140,28 +140,31 @@ impl Debug for ClassInner {
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[derive(Visit, VisitMut, TypeEq)]
 pub enum ClassKind {
-    StaticMethod,
-    ClassMethod,
-    Property,
+    StaticMethod(String),
+    ClassMethod(String),
+    Property(String),
     Class,
     EnumMember,
+    EnumNonmember,
     DataclassField,
 }
 
 impl ClassKind {
     fn from_qname(qname: &QName) -> Self {
-        match (qname.module_name().as_str(), qname.id().as_str()) {
-            ("builtins", "staticmethod") => Self::StaticMethod,
-            ("abc", "abstractstaticmethod") => Self::StaticMethod,
-            ("builtins", "classmethod") => Self::ClassMethod,
-            ("abc", "abstractclassmethod") => Self::ClassMethod,
-            ("builtins", "property") => Self::Property,
-            ("abc", "abstractproperty") => Self::Property,
-            ("functools", "cached_property") => Self::Property,
-            ("cached_property", "cached_property") => Self::Property,
-            ("cinder", "cached_property") => Self::Property,
-            ("cinder", "async_cached_property") => Self::Property,
+        let name = qname.id().as_str();
+        match (qname.module_name().as_str(), name) {
+            ("builtins", "staticmethod") => Self::StaticMethod(name.to_owned()),
+            ("abc", "abstractstaticmethod") => Self::StaticMethod(name.to_owned()),
+            ("builtins", "classmethod") => Self::ClassMethod(name.to_owned()),
+            ("abc", "abstractclassmethod") => Self::ClassMethod(name.to_owned()),
+            ("builtins", "property") => Self::Property(name.to_owned()),
+            ("abc", "abstractproperty") => Self::Property(name.to_owned()),
+            ("functools", "cached_property") => Self::Property(name.to_owned()),
+            ("cached_property", "cached_property") => Self::Property(name.to_owned()),
+            ("cinder", "cached_property") => Self::Property(name.to_owned()),
+            ("cinder", "async_cached_property") => Self::Property(name.to_owned()),
             ("enum", "member") => Self::EnumMember,
+            ("enum", "nonmember") => Self::EnumNonmember,
             ("dataclasses", "Field") => Self::DataclassField,
             _ => Self::Class,
         }

{pyrefly-0.28.0 → pyrefly-0.28.1}/crates/pyrefly_util/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/pyrefly/Cargo.toml

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

{pyrefly-0.28.0 → pyrefly-0.28.1}/pyrefly/lib/alt/answers.rs

@@ -88,6 +88,8 @@ pub struct Traces {
     types: SmallMap<TextRange, Arc<Type>>,
     /// A map from (range of callee, overload information)
     overloaded_callees: SmallMap<TextRange, OverloadedCallee>,
+    /// A map of text ranges that correspond to 'b' portion in expressions a.b where b is a property access -> getter type
+    invoked_properties: SmallMap<TextRange, Arc<Type>>,
 }
 
 /// Invariants:
@@ -558,6 +560,11 @@ impl Answers {
         lock.types.get(&range).duped()
     }
 
+    pub fn try_get_getter_for_range(&self, range: TextRange) -> Option<Arc<Type>> {
+        let lock = self.trace.as_ref()?.lock();
+        lock.invoked_properties.get(&range).duped()
+    }
+
     pub fn get_chosen_overload_trace(&self, range: TextRange) -> Option<Callable> {
         let lock = self.trace.as_ref()?.lock();
         let overloaded_callee = lock.overloaded_callees.get(&range)?;
@@ -695,6 +702,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
+    pub fn record_property_getter(&self, loc: TextRange, getter_ty: &Type) {
+        if let Some(trace) = &self.current().trace {
+            trace
+                .lock()
+                .invoked_properties
+                .insert(loc, Arc::new(getter_ty.clone()));
+        }
+    }
+
     pub fn record_type_trace(&self, loc: TextRange, ty: &Type) {
         if let Some(trace) = &self.current().trace {
             trace.lock().types.insert(loc, Arc::new(ty.clone()));

{pyrefly-0.28.0 → pyrefly-0.28.1}/pyrefly/lib/alt/attr.rs

@@ -1210,6 +1210,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             AttributeInner::Simple(ty, Visibility::ReadWrite)
             | AttributeInner::Simple(ty, Visibility::ReadOnly(_)) => Ok(ty),
             AttributeInner::Property(getter, ..) => {
+                self.record_property_getter(range, &getter);
                 Ok(self.call_property_getter(getter, range, errors, context))
             }
             AttributeInner::ModuleFallback(_, name, ty) => {

{pyrefly-0.28.0 → pyrefly-0.28.1}/pyrefly/lib/alt/class/class_field.rs

@@ -908,8 +908,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
 
         let annotation = direct_annotation.as_ref().or(inherited_annotation.as_ref());
-        let read_only_reason =
-            self.determine_read_only_reason(class, name, annotation, &value_ty, &initialization);
+        let read_only_reason = self.determine_read_only_reason(
+            class,
+            name,
+            annotation,
+            &value_ty,
+            &initialization,
+            range,
+        );
         let is_namedtuple_member = metadata
             .named_tuple_metadata()
             .is_some_and(|nt| nt.elements.contains(name));
@@ -1059,6 +1065,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         annotation: Option<&Annotation>,
         ty: &Type,
         initialization: &ClassFieldInitialization,
+        range: TextRange,
     ) -> Option<ReadOnlyReason> {
         if let Some(ann) = annotation {
             // TODO: enable this for Final attrs that aren't initialized on the class
@@ -1094,22 +1101,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             return Some(ReadOnlyReason::PydanticFrozen);
         }
 
-        // A `type[X]` that is initialized on the class is assumed to be ReadOnly. This
-        // is partly because that's what nested class defs look like to Pyrefly. But even
-        // for assignments of class objects, this implies covariance and is probably more
-        // useful than allowing reassignment but forcing invariance.
-        //
-        // TODO(stroxler): We may need to revisit this if we find projects that require
-        // read-write behavior. Covariance is known to be strictly necessary for many
-        // projects, so the obvious alternative to read-only semantics is likely to
-        // allow covariance unsoundly.
-        let is_class_object_type = match ty {
-            Type::ClassDef(..) => true,
-            Type::Type(c) if matches!(**c, Type::ClassType(..)) => true,
-            _ => false,
-        };
-        if is_class_object_type && matches!(initialization, ClassFieldInitialization::ClassBody(..))
-        {
+        // A nested class def is assumed to be ReadOnly. We distinguish a nested `class C: ...`
+        // from an assignment of a class object (`SomeAttr = C`) by checking the attribute range
+        // against the nested class definition range.
+        if matches!(ty, Type::ClassDef(cls) if cls.range() == range) {
             return Some(ReadOnlyReason::ClassObjectInitializedOnBody);
         }
         // Default: the field is read-write

{pyrefly-0.28.0 → pyrefly-0.28.1}/pyrefly/lib/alt/class/class_metadata.rs

@@ -199,7 +199,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         decorators: &[(Idx<Key>, TextRange)],
         is_new_type: bool,
         special_base: &Option<Box<BaseClass>>,
-        pydantic_metadata_binding: &Option<PydanticMetadataBinding>,
+        pydantic_metadata_binding: &PydanticMetadataBinding,
         errors: &ErrorCollector,
     ) -> ClassMetadata {
         let mut enum_metadata = None;
@@ -579,6 +579,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if let Some(dm) = dataclass_metadata.as_ref() {
             self.validate_frozen_dataclass_inheritance(cls, dm, &bases_with_metadata, errors);
         }
+
+        let has_pydantic_base_model_base_class =
+            bases_with_metadata.iter().any(|(base_class_object, _)| {
+                base_class_object.has_qname(ModuleName::pydantic().as_str(), "BaseModel")
+            });
+
+        let is_pydantic_model = has_pydantic_base_model_base_class
+            || bases_with_metadata
+                .iter()
+                .any(|(_, metadata)| metadata.is_pydantic_model());
+
         let bases = if is_typed_dict && bases_with_metadata.is_empty() {
             // This is a "fallback" class that contains attributes that are available on all TypedDict subclasses.
             // Note that this also makes those attributes available on *instances* of said subclasses; this is
@@ -593,12 +604,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 .collect::<Vec<_>>()
         };
 
-        let pydantic_metadata =
-            if let Some(PydanticMetadataBinding { frozen }) = pydantic_metadata_binding {
+        // Determine final PydanticMetadata only if the class inherits from BaseModel in the MRO
+        let pydantic_metadata = match pydantic_metadata_binding {
+            PydanticMetadataBinding { frozen } if is_pydantic_model => {
                 Some(PydanticMetadata { frozen: *frozen })
-            } else {
-                None
-            };
+            }
+            _ => None,
+        };
 
         ClassMetadata::new(
             bases,

{pyrefly-0.28.0 → pyrefly-0.28.1}/pyrefly/lib/alt/function.rs

@@ -177,11 +177,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         def: &StmtFunctionDef,
         stub_or_impl: FunctionStubOrImpl,
         class_key: Option<&Idx<KeyClass>>,
-        decorators: &[Idx<Key>],
+        decorators: &[(Idx<Key>, TextRange)],
         legacy_tparams: &[Idx<KeyLegacyTypeParam>],
         errors: &ErrorCollector,
     ) -> Arc<DecoratedFunction> {
         let defining_cls = class_key.and_then(|k| self.get_idx(*k).0.dupe());
+        let is_top_level_function = defining_cls.is_none();
         let mut self_type = defining_cls
             .as_ref()
             .map(|cls| Type::SelfType(self.as_class_type_unchecked(cls)));
@@ -202,38 +203,54 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let mut is_override = false;
         let mut has_final_decoration = false;
         let mut dataclass_transform_metadata = None;
+        let check_top_level_function_decorator = |name: &str, range| {
+            if is_top_level_function {
+                self.error(
+                    errors,
+                    range,
+                    ErrorInfo::Kind(ErrorKind::InvalidDecorator),
+                    format!("Decorator `@{name}` can only be used on methods."),
+                );
+            }
+        };
         let decorators = decorators
             .iter()
-            .filter(|k| {
-                let decorator = self.get_idx(**k);
+            .filter(|(k, range)| {
+                let decorator = self.get_idx(*k);
                 let decorator_ty = decorator.ty();
                 match decorator_ty.callee_kind() {
                     Some(CalleeKind::Function(FunctionKind::Overload)) => {
                         is_overload = true;
                         false
                     }
-                    Some(CalleeKind::Class(ClassKind::StaticMethod)) => {
+                    Some(CalleeKind::Class(ClassKind::StaticMethod(name))) => {
                         is_staticmethod = true;
+                        check_top_level_function_decorator(&name, *range);
                         false
                     }
-                    Some(CalleeKind::Class(ClassKind::ClassMethod)) => {
+                    Some(CalleeKind::Class(ClassKind::ClassMethod(name))) => {
                         is_classmethod = true;
+                        check_top_level_function_decorator(&name, *range);
                         false
                     }
-                    Some(CalleeKind::Class(ClassKind::Property)) => {
+                    Some(CalleeKind::Class(ClassKind::Property(name))) => {
                         is_property_getter = true;
+                        check_top_level_function_decorator(&name, *range);
                         false
                     }
                     Some(CalleeKind::Class(ClassKind::EnumMember)) => {
                         has_enum_member_decoration = true;
+                        check_top_level_function_decorator("member", *range);
                         false
                     }
                     Some(CalleeKind::Function(FunctionKind::Override)) => {
                         is_override = true;
+                        check_top_level_function_decorator("override", *range);
                         false
                     }
                     Some(CalleeKind::Function(FunctionKind::Final)) => {
                         has_final_decoration = true;
+                        check_top_level_function_decorator("final", *range);
                         false
                     }
                     _ if matches!(decorator_ty, Type::ClassType(cls) if cls.has_qname("warnings", "deprecated")) => {
@@ -257,6 +274,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         dataclass_transform_metadata = Some(DataclassTransformKeywords::from_type_map(&call.keywords));
                         false
                     }
+                    Some(CalleeKind::Class(ClassKind::EnumNonmember)) => {
+                        check_top_level_function_decorator("nonmember", *range);
+                        true
+                    }
+                    Some(CalleeKind::Function(FunctionKind::AbstractMethod)) => {
+                        check_top_level_function_decorator("abstractmethod", *range);
+                        true
+                    }
                     _ => true,
                 }
             })
@@ -513,7 +538,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         })
         .forall(self.validated_tparams(def.range, tparams, errors));
         ty = self.move_return_tparams(ty);
-        for x in decorators.into_iter().rev() {
+        for (x, _) in decorators.into_iter().rev() {
             ty = self.apply_function_decorator(*x, ty, &metadata, errors);
         }
         Arc::new(DecoratedFunction {