Respect attribute chains when resolving builtin call paths

crates/ruff_linter/resources/test/fixtures/pyflakes/F821_25.py

@@ -0,0 +1,5 @@
+"""Test for attribute accesses on builtins."""
+
+a = type({}).__dict__['fromkeys']
+b = dict.__dict__['fromkeys']
+assert a is b

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -1185,6 +1185,15 @@ where
                 } else {
                     self.visit_expr(value);
 
+                    println!("visit_expr: {:?}", value);
+                    let x = typing::match_annotated_subscript(
+                        value,
+                        &self.semantic,
+                        self.settings.typing_modules.iter().map(String::as_str),
+                        &self.settings.pyflakes.extend_generics,
+                    );
+                    println!("got: {:?}", x);
+
                     match typing::match_annotated_subscript(
                         value,
                         &self.semantic,

crates/ruff_linter/src/rules/pyflakes/mod.rs

@@ -144,6 +144,7 @@ mod tests {
     #[test_case(Rule::UndefinedName, Path::new("F821_22.ipynb"))]
     #[test_case(Rule::UndefinedName, Path::new("F821_23.py"))]
     #[test_case(Rule::UndefinedName, Path::new("F821_24.py"))]
+    #[test_case(Rule::UndefinedName, Path::new("F821_25.py"))]
     #[test_case(Rule::UndefinedExport, Path::new("F822_0.py"))]
     #[test_case(Rule::UndefinedExport, Path::new("F822_1.py"))]
     #[test_case(Rule::UndefinedExport, Path::new("F822_2.py"))]

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F821_F821_25.py.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/pyflakes/mod.rs
+---
+

crates/ruff_python_semantic/src/analyze/typing.rs

@@ -15,7 +15,7 @@ use crate::analyze::type_inference::{PythonType, ResolvedPythonType};
 use crate::model::SemanticModel;
 use crate::{Binding, BindingKind};
 
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub enum Callable {
     Bool,
     Cast,
@@ -26,7 +26,7 @@ pub enum Callable {
     MypyExtension,
 }
 
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub enum SubscriptKind {
     /// A subscript of the form `typing.Literal["foo", "bar"]`, i.e., a literal.
     Literal,
@@ -43,6 +43,8 @@ pub fn match_annotated_subscript<'a>(
     extend_generics: &[String],
 ) -> Option<SubscriptKind> {
     semantic.resolve_call_path(expr).and_then(|call_path| {
+        println!("call_path: {:?}", call_path);
+
         if is_standard_library_literal(call_path.as_slice()) {
             return Some(SubscriptKind::Literal);
         }

crates/ruff_python_semantic/src/model.rs

@@ -707,7 +707,20 @@ impl<'a> SemanticModel<'a> {
                     };
                 Some(resolved)
             }
-            BindingKind::Builtin => Some(smallvec!["", head.id.as_str()]),
+            BindingKind::Builtin => {
+                if value.is_name_expr() {
+                    // Ex) `dict`
+                    Some(smallvec!["", head.id.as_str()])
+                } else {
+                    // Ex) `dict.__dict__`
+                    let value_path = collect_call_path(value)?;
+                    Some(
+                        std::iter::once("")
+                            .chain(value_path.iter().copied())
+                            .collect(),
+                    )
+                }
+            }
             BindingKind::ClassDefinition(_) | BindingKind::FunctionDefinition(_) => {
                 let value_path = collect_call_path(value)?;
                 let resolved: CallPath = self