pyrefly 0.5.0__tar.gz → 0.6.0__tar.gz

{pyrefly-0.5.0 → pyrefly-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.5.0
+Version: 0.6.0
 Author: Meta
 License: MIT
 Project-URL: Source Code, https://github.com/facebook/pyre-check/tree/main/pyre2

{pyrefly-0.5.0 → pyrefly-0.6.0}/pyre2/Cargo.lock

@@ -432,9 +432,9 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.3.11"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
  "powerfmt",
 ]
@@ -699,14 +699,14 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.13.3+wasi-0.2.2",
- "windows-targets 0.52.6",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
 ]
 
 [[package]]
@@ -1523,7 +1523,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "argfile",
@@ -1598,6 +1598,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -1797,9 +1803,9 @@ checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustix"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7178faa4b75a30e269c71e61c353ce2748cf3d76f0c44c393f4e60abf49b825"
+checksum = "e56a18552996ac8d29ecc3b190b4fdbb2d91ca4ec396de7bbffaf43f3d637e96"
 dependencies = [
  "bitflags 2.9.0",
  "errno",
@@ -2046,12 +2052,12 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488960f40a3fd53d72c2a29a58722561dee8afdd175bd88e3db4677d7b2ba600"
+checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
 dependencies = [
  "fastrand",
- "getrandom 0.3.1",
+ "getrandom 0.3.2",
  "once_cell",
  "rustix",
  "windows-sys 0.59.0",
@@ -2099,9 +2105,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.39"
+version = "0.3.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dad298b01a40a23aac4580b67e3dbedb7cc8402f3592d7f49469de2ea4aecdd8"
+checksum = "9d9c75b47bdff86fa3334a3db91356b8d7d86a9b839dab7d0bdc5c3d3a077618"
 dependencies = [
  "deranged",
  "itoa",
@@ -2116,15 +2122,15 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "765c97a5b985b7c11d7bc27fa927dc4fe6af3a6dfb021d28deb60d3bf51e76ef"
+checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
 
 [[package]]
 name = "time-macros"
-version = "0.2.20"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8093bc3e81c3bc5f7879de09619d06c9a5a5e45ca44dfeeb7225bae38005c5c"
+checksum = "29aa485584182073ed57fd5004aa09c371f021325014694e432313345865fd04"
 dependencies = [
  "num-conv",
  "time-core",
@@ -2429,9 +2435,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasi"
-version = "0.13.3+wasi-0.2.2"
+version = "0.14.2+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
 dependencies = [
  "wit-bindgen-rt",
 ]
@@ -2546,9 +2552,9 @@ dependencies = [
 
 [[package]]
 name = "windows-link"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dccfd733ce2b1753b03b6d3c65edf020262ea35e20ccdf3e288043e6dd620e3"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
 name = "windows-sys"
@@ -2775,9 +2781,9 @@ dependencies = [
 
 [[package]]
 name = "wit-bindgen-rt"
-version = "0.33.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
  "bitflags 2.9.0",
 ]

{pyrefly-0.5.0 → pyrefly-0.6.0}/pyre2/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyre-check/tree/main/pyre2"
@@ -45,7 +45,7 @@ ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "112e9d
 ruff_source_file = { git = "https://github.com/astral-sh/ruff/", rev = "112e9d2d8258e72dcf5c21c7d811957f12325af1" }
 ruff_text_size = { git = "https://github.com/astral-sh/ruff/", rev = "112e9d2d8258e72dcf5c21c7d811957f12325af1" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
-serde_json = { version = "1.0.132", features = ["float_roundtrip", "unbounded_depth"] }
+serde_json = { version = "1.0.140", features = ["float_roundtrip", "unbounded_depth"] }
 starlark_map = "0.13.0"
 static_assertions = "1.1.0"
 static_interner = "0.1.1"

{pyrefly-0.5.0 → pyrefly-0.6.0}/pyre2/bin/main.rs

@@ -23,7 +23,6 @@ use pyre2::run::CheckArgs;
 use pyre2::run::CommandExitStatus;
 use pyre2::run::LspArgs;
 use pyre2::ConfigFile;
-use pyre2::FileList;
 use pyre2::Globs;
 use pyre2::NotifyWatcher;
 

{pyrefly-0.5.0 → pyrefly-0.6.0}/pyre2/lib/alt/answers.rs

@@ -8,6 +8,7 @@
 use std::fmt;
 use std::fmt::Debug;
 use std::fmt::Display;
+use std::path::PathBuf;
 use std::sync::Arc;
 
 use dupe::Dupe;
@@ -36,6 +37,7 @@ use crate::graph::index::Idx;
 use crate::graph::index_map::IndexMap;
 use crate::module::module_info::ModuleInfo;
 use crate::module::module_name::ModuleName;
+use crate::module::module_path::ModulePath;
 use crate::solver::solver::Solver;
 use crate::solver::type_order::TypeOrder;
 use crate::table;
@@ -165,15 +167,25 @@ impl Debug for SolutionsDifference<'_> {
     }
 }
 
-impl DisplayWith<ModuleInfo> for SolutionsDifference<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>, ctx: &ModuleInfo) -> fmt::Result {
+impl Display for SolutionsDifference<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let missing = |f: &mut fmt::Formatter, x: Option<(&dyn Display, &dyn Debug)>| match x {
             None => write!(f, "missing"),
             Some(x) => write!(f, "`{}`", x.0),
         };
 
+        // The key has type DisplayWith<ModuleInfo>.
+        // We don't know if the key originates on the LHS or RHS, so we don't know which is the appropriate ModuleInfo.
+        // However, we do know it is exported, and exported things can't rely on locations, so regardless
+        // of the ModuleInfo, it should display the same. Therefore, we fake one up.
+        let fake_module_info = ModuleInfo::new(
+            ModuleName::builtins(),
+            ModulePath::memory(PathBuf::new()),
+            Default::default(),
+        );
+
         write!(f, "`")?;
-        self.key.0.fmt(f, ctx)?;
+        self.key.0.fmt(f, &fake_module_info)?;
         write!(f, "` was ")?;
         missing(f, self.lhs)?;
         write!(f, " now ")?;
@@ -202,6 +214,7 @@ impl Solutions {
         fn f<'a, K: Keyed>(
             x: &'a SolutionsEntry<K>,
             y: &'a Solutions,
+            ctx: &mut TypeEqCtx,
         ) -> Option<SolutionsDifference<'a>>
         where
             SolutionsTable: TableKeyed<K, Value = SolutionsEntry<K>>,
@@ -221,7 +234,7 @@ impl Solutions {
             }
             for (k, v) in x.iter() {
                 match y.get(k) {
-                    Some(v2) if !v.type_eq(v2, &mut TypeEqCtx::default()) => {
+                    Some(v2) if !v.type_eq(v2, ctx) => {
                         return Some(SolutionsDifference {
                             key: (k, k),
                             lhs: Some((v, v)),
@@ -242,9 +255,12 @@ impl Solutions {
         }
 
         let mut difference = None;
+        // Important we have a single TypeEqCtx, so that we don't have
+        // types used in different ways.
+        let mut ctx = TypeEqCtx::default();
         table_for_each!(self.0, |x| {
             if difference.is_none() {
-                difference = f(x, other);
+                difference = f(x, other, &mut ctx);
             }
         });
         difference
@@ -579,7 +595,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         got: &Type,
         loc: TextRange,
         errors: &ErrorCollector,
-        tcc: &TypeCheckContext,
+        tcc: &dyn Fn() -> TypeCheckContext,
     ) -> Type {
         if matches!(got, Type::Any(AnyStyle::Error)) {
             // Don't propagate errors
@@ -621,7 +637,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
         range: TextRange,
         kind: ErrorKind,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         msg: String,
     ) -> Type {
         errors.add(range, msg, kind, context);

{pyrefly-0.5.0 → pyrefly-0.6.0}/pyre2/lib/alt/attr.rs

@@ -17,6 +17,7 @@ use crate::alt::answers::LookupAnswer;
 use crate::alt::callable::CallArg;
 use crate::alt::types::class_metadata::EnumMetadata;
 use crate::binding::binding::KeyExport;
+use crate::dunder;
 use crate::error::collector::ErrorCollector;
 use crate::error::context::ErrorContext;
 use crate::error::context::TypeCheckContext;
@@ -62,7 +63,7 @@ pub struct Attribute {
 ///
 /// The operation is either permitted with an attribute `Type`, or is not allowed
 /// and has a reason.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 enum AttributeInner {
     /// A `NoAccess` attribute indicates that the attribute is well-defined, but does
     /// not allow the access pattern (for example class access on an instance-only attribute)
@@ -77,6 +78,13 @@ enum AttributeInner {
     /// A descriptor is a user-defined type whose actions may dispatch to special method calls
     /// for the get and set actions.
     Descriptor(Descriptor),
+    /// The attribute being looked up is not defined explicitly, but it may be defined via a
+    /// __getattr__ fallback.
+    /// The `NotFound` field stores the (failed) lookup result on the original attribute for
+    /// better error reporting downstream. The `AttributeInner` field stores the (successful)
+    /// lookup result of the `__getattr__` function or method. The `Name` field stores the name
+    /// of the original attribute being looked up.
+    GetAttr(NotFound, Box<AttributeInner>, Name),
 }
 
 #[derive(Clone, Debug)]
@@ -105,7 +113,7 @@ pub enum DescriptorBase {
 }
 
 #[derive(Debug)]
-enum NotFound {
+pub enum NotFound {
     Attribute(ClassType),
     ClassAttribute(Class),
     ModuleExport(Module),
@@ -135,6 +143,10 @@ enum InternalError {
 }
 
 impl Attribute {
+    fn new(inner: AttributeInner) -> Self {
+        Attribute { inner }
+    }
+
     pub fn no_access(reason: NoAccessReason) -> Self {
         Attribute {
             inner: AttributeInner::NoAccess(reason),
@@ -174,6 +186,12 @@ impl Attribute {
             }),
         }
     }
+
+    pub fn getattr(not_found: NotFound, getattr: Attribute, name: Name) -> Self {
+        Attribute {
+            inner: AttributeInner::GetAttr(not_found, Box::new(getattr.inner), name),
+        }
+    }
 }
 
 impl NoAccessReason {
@@ -285,7 +303,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         attr_name: &Name,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) -> Type {
         let lookup_result = self.lookup_attr(base, attr_name);
@@ -311,7 +329,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         attr_name: &Name,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) -> Option<Type> {
         match self.lookup_attr(base, attr_name) {
@@ -346,10 +364,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         match self.lookup_attr(&base, &Name::new_static("_value_")) {
             LookupResult::Found(attr) => match attr.inner {
                 AttributeInner::ReadWrite(ty) => Some(ty),
+                // NOTE: We currently do not expect to use `__getattr__` for `_value_` annotation lookup.
                 AttributeInner::ReadOnly(_)
                 | AttributeInner::NoAccess(_)
                 | AttributeInner::Property(..)
-                | AttributeInner::Descriptor(..) => None,
+                | AttributeInner::Descriptor(..)
+                | AttributeInner::GetAttr(..) => None,
             },
             _ => None,
         }
@@ -364,7 +384,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         got: Either<&Expr, &Type>,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) {
         match self.lookup_attr(base, attr_name) {
@@ -382,27 +402,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     Either::Left(got) => {
                         self.expr(
                             got,
-                            Some((
-                                &want,
-                                &TypeCheckContext {
-                                    kind: TypeCheckKind::Attribute(attr_name.clone()),
-                                    context: context.cloned(),
-                                },
-                            )),
+                            Some((&want, &|| TypeCheckContext {
+                                kind: TypeCheckKind::Attribute(attr_name.clone()),
+                                context: context.map(|ctx| ctx()),
+                            })),
                             errors,
                         );
                     }
                     Either::Right(got) => {
-                        self.check_type(
-                            &want,
-                            got,
-                            range,
-                            errors,
-                            &TypeCheckContext {
-                                kind: TypeCheckKind::Attribute(attr_name.clone()),
-                                context: context.cloned(),
-                            },
-                        );
+                        self.check_type(&want, got, range, errors, &|| TypeCheckContext {
+                            kind: TypeCheckKind::Attribute(attr_name.clone()),
+                            context: context.map(|ctx| ctx()),
+                        });
                     }
                 },
                 AttributeInner::ReadOnly(_) => {
@@ -466,6 +477,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         }
                     };
                 }
+                AttributeInner::GetAttr(not_found, _, name) => {
+                    // Attribute setting bypasses `__getattr__` lookup and behaves the same
+                    // as if the `__getattr__` lookup did not happen.
+                    self.error(
+                        errors,
+                        range,
+                        ErrorKind::MissingAttribute,
+                        context,
+                        not_found.to_error_msg(&name),
+                    );
+                }
             },
             LookupResult::InternalError(e) => {
                 self.error(
@@ -495,7 +517,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         got: &Expr,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) {
         self.check_attr_set(
@@ -516,7 +538,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         got: &Type,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) {
         self.check_attr_set(
@@ -536,7 +558,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         attr_name: &Name,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) {
         match self.lookup_attr(base, attr_name) {
@@ -564,6 +586,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         format!("Cannot delete read-only field `{attr_name}`"),
                     );
                 }
+                AttributeInner::GetAttr(not_found, _, name) => {
+                    // Attribute deleting bypasses `__getattr__` lookup and behaves the same
+                    // as if the `__getattr__` lookup did not happen.
+                    self.error(
+                        errors,
+                        range,
+                        ErrorKind::MissingAttribute,
+                        context,
+                        not_found.to_error_msg(&name),
+                    );
+                }
             },
             LookupResult::InternalError(e) => {
                 self.error(
@@ -673,6 +706,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 ),
             ) => is_subset(got_ty, want_ty),
             (AttributeInner::Descriptor(..), _) | (_, AttributeInner::Descriptor(..)) => false,
+            (AttributeInner::GetAttr(..), _) | (_, AttributeInner::GetAttr(..)) => {
+                // NOTE(grievejia): `__getattr__` does not participate in structural subtyping
+                // check for now. We may revisit this in the future if the need comes.
+                false
+            }
         }
     }
 
@@ -681,7 +719,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         attr: Attribute,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Result<Type, NoAccessReason> {
         match attr.inner {
             AttributeInner::NoAccess(reason) => Err(reason),
@@ -708,6 +746,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     } => Ok(descriptor_ty),
                 }
             }
+            AttributeInner::GetAttr(_, getattr_attr, name) => self
+                .resolve_get_access(Attribute::new(*getattr_attr), range, errors, context)
+                .map(|getattr_ty| self.call_getattr(getattr_ty, name, range, errors, context)),
         }
     }
 
@@ -723,22 +764,28 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         inner: AttributeInner,
     ) -> Option<Type> {
         match inner {
-            AttributeInner::ReadWrite(ty) => Some(ty),
-            AttributeInner::ReadOnly(_)
-            | AttributeInner::NoAccess(_)
+            // TODO(stroxler): ReadWrite attributes are not actually methods but limiting access to
+            // ReadOnly breaks unit tests; we should investigate callsites to understand this better.
+            // NOTE(grievejia): We currently do not expect to use `__getattr__` for this lookup.
+            AttributeInner::ReadOnly(ty) | AttributeInner::ReadWrite(ty) => Some(ty),
+            AttributeInner::NoAccess(_)
             | AttributeInner::Property(..)
-            | AttributeInner::Descriptor(..) => None,
+            | AttributeInner::Descriptor(..)
+            | AttributeInner::GetAttr(..) => None,
         }
     }
 
     pub fn resolve_named_tuple_element(&self, attr: Attribute) -> Option<Type> {
         // NamedTuples are immutable, so their attributes are always read-only
+        // NOTE(grievejia): We do not use `__getattr__` here because this lookup is expected to be inovked
+        // on NamedTuple attributes with known names.
         match attr.inner {
             AttributeInner::ReadOnly(ty) => Some(ty),
             AttributeInner::ReadWrite(_)
             | AttributeInner::NoAccess(_)
             | AttributeInner::Property(..)
-            | AttributeInner::Descriptor(..) => None,
+            | AttributeInner::Descriptor(..)
+            | AttributeInner::GetAttr(..) => None,
         }
     }
 
@@ -750,7 +797,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         attr_name: &Name,
         range: TextRange,
         errors: &ErrorCollector,
-        context: Option<&ErrorContext>,
+        context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) -> Result<Type, String> {
         match lookup {
@@ -774,12 +821,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             AttributeBase::ClassInstance(class) => {
                 match self.get_instance_attribute(&class, attr_name) {
                     Some(attr) => LookupResult::Found(attr),
+                    None if self.extends_any(&class) => {
+                        LookupResult::found_type(Type::Any(AnyStyle::Implicit))
+                    }
                     None => LookupResult::NotFound(NotFound::Attribute(class)),
                 }
             }
             AttributeBase::SuperInstance(cls, obj) => {
                 match self.get_super_attribute(&cls, &obj, attr_name) {
                     Some(attr) => LookupResult::Found(attr),
+                    None if self.extends_any(&obj) => {
+                        LookupResult::found_type(Type::Any(AnyStyle::Implicit))
+                    }
                     None => LookupResult::NotFound(NotFound::Attribute(cls)),
                 }
             }
@@ -797,6 +850,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         };
                         match instance_attr {
                             Some(attr) => LookupResult::Found(attr),
+                            None if metadata.has_base_any() => {
+                                // We can't immediately fall back to Any in this case -- `type[Any]` is actually a special
+                                // AttributeBase which requires additional lookup on `type` itself before the Any fallback.
+                                self.lookup_attr_from_attribute_base(
+                                    AttributeBase::TypeAny(AnyStyle::Implicit),
+                                    attr_name,
+                                )
+                            }
                             None => LookupResult::NotFound(NotFound::ClassAttribute(class)),
                         }
                     }
@@ -861,10 +922,30 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     fn lookup_attr(&self, base: &Type, attr_name: &Name) -> LookupResult {
         match self.as_attribute_base(base.clone(), self.stdlib) {
-            Some(base) => self.lookup_attr_from_attribute_base(base, attr_name),
             None => {
                 LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone()))
             }
+            Some(base) => {
+                let direct_lookup_result =
+                    self.lookup_attr_from_attribute_base(base.clone(), attr_name);
+                match direct_lookup_result {
+                    LookupResult::Found(_) | LookupResult::InternalError(_) => direct_lookup_result,
+                    LookupResult::NotFound(not_found) => {
+                        let getattr_lookup_result =
+                            self.lookup_attr_from_attribute_base(base, &dunder::GETATTR);
+                        match getattr_lookup_result {
+                            LookupResult::NotFound(_) | LookupResult::InternalError(_) => {
+                                LookupResult::NotFound(not_found)
+                            }
+                            LookupResult::Found(attr) => LookupResult::Found(Attribute::getattr(
+                                not_found,
+                                attr,
+                                attr_name.clone(),
+                            )),
+                        }
+                    }
+                }
+            }
         }
     }