Bump version to 0.0.23

Cargo.lock

@@ -850,6 +850,12 @@ dependencies = [
  "wasi 0.11.0+wasi-snapshot-preview1",
 ]
 
+[[package]]
+name = "glob"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+
 [[package]]
 name = "gloo-timers"
 version = "0.2.4"
@@ -1635,7 +1641,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.21"
+version = "0.0.23"
 dependencies = [
  "anyhow",
  "bincode",
@@ -1648,6 +1654,7 @@ dependencies = [
  "dirs 4.0.0",
  "fern",
  "filetime",
+ "glob",
  "log",
  "notify",
  "rayon",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.21"
+version = "0.0.23"
 edition = "2021"
 
 [lib]
@@ -18,6 +18,7 @@ common-path = { version = "1.0.0" }
 dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.17" }
+glob = { version = "0.3.0"}
 log = { version = "0.4.17" }
 notify = { version = "4.0.17" }
 rayon = { version = "1.5.3" }

resources/test/src/F704.py

@@ -0,0 +1,10 @@
+def f() -> int:
+    yield 1
+
+
+class Foo:
+    yield 2
+
+
+yield 3
+yield from 3

resources/test/src/F821.py

@@ -40,9 +40,7 @@ class Class:
         # TODO(charlie): This should be recognized as a defined variable.
         Class  # noqa: F821
 
-
 try:
     x = 1 / 0
 except Exception as e:
-    # TODO(charlie): This should be recognized as a defined variable.
-    print(e)  # noqa: F821
+    print(e)

resources/test/src/F841.py

@@ -0,0 +1,16 @@
+try:
+    1 / 0
+except ValueError as e:
+    pass
+
+
+try:
+    1 / 0
+except ValueError as e:
+    print(e)
+
+
+def f():
+    x = 1
+    y = 2
+    z = x + y

resources/test/src/bar/migrations/migration.py

@@ -0,0 +1,9 @@
+a = "abc"
+b = f"ghi{'jkl'}"
+
+c = f"def"
+d = f"def" + "ghi"
+e = (
+    f"def" +
+    "ghi"
+)

resources/test/src/foo/migrations/migration.py

@@ -0,0 +1,9 @@
+a = "abc"
+b = f"ghi{'jkl'}"
+
+c = f"def"
+d = f"def" + "ghi"
+e = (
+    f"def" +
+    "ghi"
+)

resources/test/src/pyproject.toml

@@ -1,15 +1,17 @@
 [tool.ruff]
 line-length = 88
-exclude = ["excluded.py"]
+exclude = ["excluded.py", "**/migrations"]
 select = [
     "E501",
     "F401",
     "F403",
     "F541",
     "F634",
+    "F704",
     "F706",
     "F821",
     "F831",
     "F832",
+    "F841",
     "F901",
 ]

src/cache.rs

@@ -66,7 +66,7 @@ impl From<bool> for Mode {
 }
 
 fn cache_dir() -> &'static str {
-    "./.cache"
+    "./.ruff_cache"
 }
 
 fn cache_key(path: &Path, settings: &Settings) -> String {

src/check_ast.rs

@@ -1,17 +1,18 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use crate::builtins::{BUILTINS, MAGIC_GLOBALS};
 use rustpython_parser::ast::{
-    Arg, Arguments, Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind, Suite,
+    Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
+    Location, Stmt, StmtKind, Suite,
 };
 use rustpython_parser::parser;
 
+use crate::builtins::{BUILTINS, MAGIC_GLOBALS};
 use crate::check_ast::ScopeKind::{Class, Function, Generator, Module};
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::settings::Settings;
 use crate::visitor;
-use crate::visitor::Visitor;
+use crate::visitor::{walk_excepthandler, Visitor};
 
 fn id() -> usize {
     static COUNTER: AtomicUsize = AtomicUsize::new(1);
@@ -41,6 +42,7 @@ impl Scope {
     }
 }
 
+#[derive(Clone)]
 enum BindingKind {
     Argument,
     Assignment,
@@ -53,6 +55,7 @@ enum BindingKind {
     SubmoduleImportation(String),
 }
 
+#[derive(Clone)]
 struct Binding {
     kind: BindingKind,
     location: Location,
@@ -111,7 +114,6 @@ impl Visitor for Checker<'_> {
                     name.to_string(),
                     Binding {
                         kind: BindingKind::Definition,
-
                         used: None,
                         location: stmt.location,
                     },
@@ -123,7 +125,6 @@ impl Visitor for Checker<'_> {
                     name.to_string(),
                     Binding {
                         kind: BindingKind::Definition,
-
                         used: None,
                         location: stmt.location,
                     },
@@ -153,6 +154,8 @@ impl Visitor for Checker<'_> {
             StmtKind::Import { names } => {
                 for alias in names {
                     if alias.node.name.contains('.') && alias.node.asname.is_none() {
+                        // TODO(charlie): Multiple submodule imports with the same parent module
+                        // will be merged into a single binding.
                         self.add_binding(
                             alias.node.name.split('.').next().unwrap().to_string(),
                             Binding {
@@ -277,19 +280,40 @@ impl Visitor for Checker<'_> {
                     }
                 }
             }
-            StmtKind::AugAssign { target, .. } => {
-                self.handle_node_load(target);
-            }
+            StmtKind::AugAssign { target, .. } => self.handle_node_load(target),
             _ => {}
         }
 
         visitor::walk_stmt(self, stmt);
 
         match &stmt.node {
-            StmtKind::ClassDef { .. }
-            | StmtKind::FunctionDef { .. }
-            | StmtKind::AsyncFunctionDef { .. } => {
-                self.pop_scope();
+            StmtKind::ClassDef { .. } => {
+                if let Some(scope) = self.scopes.pop() {
+                    self.dead_scopes.push(scope);
+                }
+            }
+            StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                let scope = self.scopes.last().expect("No current scope found.");
+                for (name, binding) in scope.values.iter() {
+                    // TODO(charlie): Ignore if using `locals`.
+                    if self.settings.select.contains(&CheckCode::F841)
+                        && binding.used.is_none()
+                        && name != "_"
+                        && name != "__tracebackhide__"
+                        && name != "__traceback_info__"
+                        && name != "__traceback_supplement__"
+                        && matches!(binding.kind, BindingKind::Assignment)
+                    {
+                        self.checks.push(Check {
+                            kind: CheckKind::UnusedVariable(name.to_string()),
+                            location: binding.location,
+                        });
+                    }
+                }
+
+                if let Some(scope) = self.scopes.pop() {
+                    self.dead_scopes.push(scope);
+                }
             }
             _ => {}
         };
@@ -299,14 +323,12 @@ impl Visitor for Checker<'_> {
                 name.to_string(),
                 Binding {
                     kind: BindingKind::ClassDefinition,
-
                     used: None,
                     location: stmt.location,
                 },
             );
         }
     }
-
     fn visit_annotation(&mut self, expr: &Expr) {
         let initial = self.in_annotation;
         self.in_annotation = true;
@@ -327,6 +349,21 @@ impl Visitor for Checker<'_> {
             | ExprKind::DictComp { .. }
             | ExprKind::SetComp { .. } => self.push_scope(Scope::new(Generator)),
             ExprKind::Lambda { .. } => self.push_scope(Scope::new(Function)),
+            ExprKind::Yield { .. } | ExprKind::YieldFrom { .. } => {
+                let scope = self.scopes.last().expect("No current scope found.");
+                if self
+                    .settings
+                    .select
+                    .contains(CheckKind::YieldOutsideFunction.code())
+                    && matches!(scope.kind, ScopeKind::Class)
+                    || matches!(scope.kind, ScopeKind::Module)
+                {
+                    self.checks.push(Check {
+                        kind: CheckKind::YieldOutsideFunction,
+                        location: expr.location,
+                    });
+                }
+            }
             ExprKind::JoinedStr { values } => {
                 if !self.in_f_string
                     && self
@@ -370,6 +407,53 @@ impl Visitor for Checker<'_> {
         };
     }
 
+    fn visit_excepthandler(&mut self, excepthandler: &Excepthandler) {
+        match &excepthandler.node {
+            ExcepthandlerKind::ExceptHandler { name, .. } => match name {
+                Some(name) => {
+                    let scope = self.scopes.last().expect("No current scope found.");
+                    if scope.values.contains_key(name) {
+                        self.handle_node_store(&Expr::new(
+                            excepthandler.location,
+                            ExprKind::Name {
+                                id: name.to_string(),
+                                ctx: ExprContext::Store,
+                            },
+                        ));
+                    }
+
+                    let scope = self.scopes.last().expect("No current scope found.");
+                    let prev_definition = scope.values.get(name).cloned();
+                    self.handle_node_store(&Expr::new(
+                        excepthandler.location,
+                        ExprKind::Name {
+                            id: name.to_string(),
+                            ctx: ExprContext::Store,
+                        },
+                    ));
+
+                    walk_excepthandler(self, excepthandler);
+
+                    let scope = self.scopes.last_mut().expect("No current scope found.");
+                    if let Some(binding) = scope.values.remove(name) {
+                        if self.settings.select.contains(&CheckCode::F841) && binding.used.is_none()
+                        {
+                            self.checks.push(Check {
+                                kind: CheckKind::UnusedVariable(name.to_string()),
+                                location: excepthandler.location,
+                            });
+                        }
+                    }
+
+                    if let Some(binding) = prev_definition {
+                        scope.values.insert(name.to_string(), binding);
+                    }
+                }
+                None => walk_excepthandler(self, excepthandler),
+            },
+        }
+    }
+
     fn visit_arguments(&mut self, arguments: &Arguments) {
         if self
             .settings

src/checks.rs

@@ -12,10 +12,12 @@ pub enum CheckCode {
     F403,
     F541,
     F634,
+    F704,
     F706,
     F821,
     F831,
     F832,
+    F841,
     F901,
 }
 
@@ -29,10 +31,12 @@ impl FromStr for CheckCode {
             "F403" => Ok(CheckCode::F403),
             "F541" => Ok(CheckCode::F541),
             "F634" => Ok(CheckCode::F634),
+            "F704" => Ok(CheckCode::F704),
             "F706" => Ok(CheckCode::F706),
             "F821" => Ok(CheckCode::F821),
             "F831" => Ok(CheckCode::F831),
             "F832" => Ok(CheckCode::F832),
+            "F841" => Ok(CheckCode::F841),
             "F901" => Ok(CheckCode::F901),
             _ => Err(anyhow::anyhow!("Unknown check code: {s}")),
         }
@@ -47,10 +51,12 @@ impl CheckCode {
             CheckCode::F403 => "F403",
             CheckCode::F541 => "F541",
             CheckCode::F634 => "F634",
+            CheckCode::F704 => "F704",
             CheckCode::F706 => "F706",
             CheckCode::F821 => "F821",
             CheckCode::F831 => "F831",
             CheckCode::F832 => "F832",
+            CheckCode::F841 => "F841",
             CheckCode::F901 => "F901",
         }
     }
@@ -63,10 +69,12 @@ impl CheckCode {
             CheckCode::F403 => &LintSource::AST,
             CheckCode::F541 => &LintSource::AST,
             CheckCode::F634 => &LintSource::AST,
+            CheckCode::F704 => &LintSource::AST,
             CheckCode::F706 => &LintSource::AST,
             CheckCode::F821 => &LintSource::AST,
             CheckCode::F831 => &LintSource::AST,
             CheckCode::F832 => &LintSource::AST,
+            CheckCode::F841 => &LintSource::AST,
             CheckCode::F901 => &LintSource::AST,
         }
     }
@@ -86,9 +94,11 @@ pub enum CheckKind {
     ImportStarUsage,
     LineTooLong,
     RaiseNotImplemented,
+    YieldOutsideFunction,
     ReturnOutsideFunction,
     UndefinedName(String),
     UndefinedLocal(String),
+    UnusedVariable(String),
     UnusedImport(String),
 }
 
@@ -102,9 +112,11 @@ impl CheckKind {
             CheckKind::ImportStarUsage => &CheckCode::F403,
             CheckKind::LineTooLong => &CheckCode::E501,
             CheckKind::RaiseNotImplemented => &CheckCode::F901,
+            CheckKind::YieldOutsideFunction => &CheckCode::F704,
             CheckKind::ReturnOutsideFunction => &CheckCode::F706,
             CheckKind::UndefinedName(_) => &CheckCode::F821,
             CheckKind::UndefinedLocal(_) => &CheckCode::F832,
+            CheckKind::UnusedVariable(_) => &CheckCode::F841,
             CheckKind::UnusedImport(_) => &CheckCode::F401,
         }
     }
@@ -118,20 +130,24 @@ impl CheckKind {
             CheckKind::FStringMissingPlaceholders => {
                 "f-string without any placeholders".to_string()
             }
-            CheckKind::IfTuple => {
-                "If test is a tuple.to_string(), which is always `True`".to_string()
-            }
+            CheckKind::IfTuple => "If test is a tuple, which is always `True`".to_string(),
             CheckKind::ImportStarUsage => "Unable to detect undefined names".to_string(),
             CheckKind::LineTooLong => "Line too long".to_string(),
             CheckKind::RaiseNotImplemented => {
                 "'raise NotImplemented' should be 'raise NotImplementedError".to_string()
             }
+            CheckKind::YieldOutsideFunction => {
+                "a `yield` or `yield from` statement outside of a function/method".to_string()
+            }
             CheckKind::ReturnOutsideFunction => {
                 "a `return` statement outside of a function/method".to_string()
             }
             CheckKind::UndefinedName(name) => {
                 format!("Undefined name `{name}`")
             }
+            CheckKind::UnusedVariable(name) => {
+                format!("Local variable `{name}` is assigned to but never used")
+            }
             CheckKind::UndefinedLocal(name) => {
                 format!("Local variable `{name}` referenced before assignment")
             }

src/fs.rs

@@ -3,21 +3,33 @@ use std::io::{BufReader, Read};
 use std::path::{Path, PathBuf};
 
 use anyhow::Result;
+use glob::Pattern;
 use walkdir::{DirEntry, WalkDir};
 
 fn is_not_hidden(entry: &DirEntry) -> bool {
     entry
         .file_name()
         .to_str()
-        .map(|s| entry.depth() == 0 || !s.starts_with('.'))
+        .map(|s| (entry.depth() == 0 || !s.starts_with('.')))
         .unwrap_or(false)
 }
 
-pub fn iter_python_files(path: &PathBuf) -> impl Iterator<Item = DirEntry> {
+fn is_not_excluded(entry: &DirEntry, exclude: &[Pattern]) -> bool {
+    entry
+        .path()
+        .to_str()
+        .map(|s| !exclude.iter().any(|pattern| pattern.matches(s)))
+        .unwrap_or(false)
+}
+
+pub fn iter_python_files<'a>(
+    path: &'a PathBuf,
+    exclude: &'a [Pattern],
+) -> impl Iterator<Item = DirEntry> + 'a {
     WalkDir::new(path)
         .follow_links(true)
         .into_iter()
-        .filter_entry(is_not_hidden)
+        .filter_entry(|entry| is_not_hidden(entry) && is_not_excluded(entry, exclude))
         .filter_map(|entry| entry.ok())
         .filter(|entry| entry.path().to_string_lossy().ends_with(".py"))
 }

src/linter.rs

@@ -222,6 +222,42 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn f704() -> Result<()> {
+        let actual = check_path(
+            &Path::new("./resources/test/src/F704.py"),
+            &settings::Settings {
+                line_length: 88,
+                exclude: vec![],
+                select: BTreeSet::from([CheckCode::F704]),
+            },
+            &cache::Mode::None,
+        )?;
+        let expected = vec![
+            Message {
+                kind: CheckKind::YieldOutsideFunction,
+                location: Location::new(6, 5),
+                filename: "./resources/test/src/F704.py".to_string(),
+            },
+            Message {
+                kind: CheckKind::YieldOutsideFunction,
+                location: Location::new(9, 1),
+                filename: "./resources/test/src/F704.py".to_string(),
+            },
+            Message {
+                kind: CheckKind::YieldOutsideFunction,
+                location: Location::new(10, 1),
+                filename: "./resources/test/src/F704.py".to_string(),
+            },
+        ];
+        assert_eq!(actual.len(), expected.len());
+        for i in 0..actual.len() {
+            assert_eq!(actual[i], expected[i]);
+        }
+
+        Ok(())
+    }
+
     #[test]
     fn f706() -> Result<()> {
         let actual = check_path(
@@ -354,6 +390,37 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn f841() -> Result<()> {
+        let actual = check_path(
+            &Path::new("./resources/test/src/F841.py"),
+            &settings::Settings {
+                line_length: 88,
+                exclude: vec![],
+                select: BTreeSet::from([CheckCode::F841]),
+            },
+            &cache::Mode::None,
+        )?;
+        let expected = vec![
+            Message {
+                kind: CheckKind::UnusedVariable("e".to_string()),
+                location: Location::new(3, 1),
+                filename: "./resources/test/src/F841.py".to_string(),
+            },
+            Message {
+                kind: CheckKind::UnusedVariable("z".to_string()),
+                location: Location::new(16, 5),
+                filename: "./resources/test/src/F841.py".to_string(),
+            },
+        ];
+        assert_eq!(actual.len(), expected.len());
+        for i in 0..actual.len() {
+            assert_eq!(actual[i], expected[i]);
+        }
+
+        Ok(())
+    }
+
     #[test]
     fn f901() -> Result<()> {
         let actual = check_path(

src/main.rs

@@ -51,19 +51,16 @@ struct Cli {
 fn run_once(files: &[PathBuf], settings: &Settings, cache: bool) -> Result<Vec<Message>> {
     // Collect all the files to check.
     let start = Instant::now();
-    let files: Vec<DirEntry> = files.iter().flat_map(iter_python_files).collect();
+    let files: Vec<DirEntry> = files
+        .iter()
+        .flat_map(|path| iter_python_files(path, &settings.exclude))
+        .collect();
     let duration = start.elapsed();
     debug!("Identified files to lint in: {:?}", duration);
 
     let start = Instant::now();
     let mut messages: Vec<Message> = files
         .par_iter()
-        .filter(|entry| {
-            !settings
-                .exclude
-                .iter()
-                .any(|exclusion| entry.path().starts_with(exclusion))
-        })
         .map(|entry| {
             check_path(entry.path(), settings, &cache.into()).unwrap_or_else(|e| {
                 error!("Failed to check {}: {e:?}", entry.path().to_string_lossy());

src/pyproject.rs

@@ -14,12 +14,20 @@ pub fn load_config<'a>(paths: impl IntoIterator<Item = &'a Path>) -> Result<(Pat
         Some(project_root) => match find_pyproject_toml(&project_root) {
             Some(path) => {
                 debug!("Found pyproject.toml at: {}", path.to_string_lossy());
-                let pyproject = parse_pyproject_toml(&path)?;
-                let config = pyproject
-                    .tool
-                    .and_then(|tool| tool.ruff)
-                    .unwrap_or_default();
-                Ok((project_root, config))
+                match parse_pyproject_toml(&path) {
+                    Ok(pyproject) => {
+                        let config = pyproject
+                            .tool
+                            .and_then(|tool| tool.ruff)
+                            .unwrap_or_default();
+                        Ok((project_root, config))
+                    }
+                    Err(e) => {
+                        println!("Failed to load pyproject.toml: {:?}", e);
+                        println!("Falling back to default configuration...");
+                        Ok(Default::default())
+                    }
+                }
             }
             None => Ok(Default::default()),
         },
@@ -225,17 +233,22 @@ other-attribute = 1
             config,
             Config {
                 line_length: Some(88),
-                exclude: Some(vec![Path::new("excluded.py").to_path_buf()]),
+                exclude: Some(vec![
+                    Path::new("excluded.py").to_path_buf(),
+                    Path::new("**/migrations").to_path_buf()
+                ]),
                 select: Some(BTreeSet::from([
                     CheckCode::E501,
                     CheckCode::F401,
                     CheckCode::F403,
                     CheckCode::F541,
                     CheckCode::F634,
+                    CheckCode::F704,
                     CheckCode::F706,
                     CheckCode::F821,
                     CheckCode::F831,
                     CheckCode::F832,
+                    CheckCode::F841,
                     CheckCode::F901,
                 ])),
             }

src/settings.rs

@@ -1,8 +1,9 @@
 use std::collections::BTreeSet;
 use std::hash::{Hash, Hasher};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use anyhow::Result;
+use glob::Pattern;
 
 use crate::checks::CheckCode;
 use crate::pyproject::load_config;
@@ -10,7 +11,7 @@ use crate::pyproject::load_config;
 #[derive(Debug)]
 pub struct Settings {
     pub line_length: usize,
-    pub exclude: Vec<PathBuf>,
+    pub exclude: Vec<Pattern>,
     pub select: BTreeSet<CheckCode>,
 }
 
@@ -39,6 +40,7 @@ impl Settings {
                         path
                     }
                 })
+                .map(|path| Pattern::new(&path.to_string_lossy()).expect("Invalid pattern."))
                 .collect(),
             select: config.select.unwrap_or_else(|| {
                 BTreeSet::from([

src/visitor.rs

@@ -14,9 +14,6 @@ pub trait Visitor {
     fn visit_expr(&mut self, expr: &Expr) {
         walk_expr(self, expr);
     }
-    fn visit_ident(&mut self, ident: &str) {
-        walk_ident(self, ident);
-    }
     fn visit_constant(&mut self, constant: &Constant) {
         walk_constant(self, constant);
     }
@@ -67,53 +64,48 @@ pub trait Visitor {
 pub fn walk_stmt<V: Visitor + ?Sized>(visitor: &mut V, stmt: &Stmt) {
     match &stmt.node {
         StmtKind::FunctionDef {
-            name,
             args,
             body,
             decorator_list,
             returns,
             ..
         } => {
-            visitor.visit_ident(name);
             visitor.visit_arguments(args);
-            for stmt in body {
-                visitor.visit_stmt(stmt)
-            }
             for expr in decorator_list {
                 visitor.visit_expr(expr)
             }
             for expr in returns {
                 visitor.visit_annotation(expr);
             }
+            for stmt in body {
+                visitor.visit_stmt(stmt)
+            }
         }
         StmtKind::AsyncFunctionDef {
-            name,
             args,
             body,
             decorator_list,
             returns,
             ..
         } => {
-            visitor.visit_ident(name);
             visitor.visit_arguments(args);
-            for stmt in body {
-                visitor.visit_stmt(stmt)
-            }
             for expr in decorator_list {
                 visitor.visit_expr(expr)
             }
             for expr in returns {
                 visitor.visit_annotation(expr);
             }
+            for stmt in body {
+                visitor.visit_stmt(stmt)
+            }
         }
         StmtKind::ClassDef {
-            name,
             bases,
             keywords,
             body,
             decorator_list,
+            ..
         } => {
-            visitor.visit_ident(name);
             for expr in bases {
                 visitor.visit_expr(expr)
             }
@@ -271,24 +263,13 @@ pub fn walk_stmt<V: Visitor + ?Sized>(visitor: &mut V, stmt: &Stmt) {
                 visitor.visit_alias(alias);
             }
         }
-        StmtKind::ImportFrom { module, names, .. } => {
-            if let Some(ident) = module {
-                visitor.visit_ident(ident);
-            }
+        StmtKind::ImportFrom { names, .. } => {
             for alias in names {
                 visitor.visit_alias(alias);
             }
         }
-        StmtKind::Global { names } => {
-            for ident in names {
-                visitor.visit_ident(ident)
-            }
-        }
-        StmtKind::Nonlocal { names } => {
-            for ident in names {
-                visitor.visit_ident(ident)
-            }
-        }
+        StmtKind::Global { .. } => {}
+        StmtKind::Nonlocal { .. } => {}
         StmtKind::Expr { value } => visitor.visit_expr(value),
         StmtKind::Pass => {}
         StmtKind::Break => {}
@@ -428,8 +409,7 @@ pub fn walk_expr<V: Visitor + ?Sized>(visitor: &mut V, expr: &Expr) {
             visitor.visit_expr(value);
             visitor.visit_expr_context(ctx);
         }
-        ExprKind::Name { id, ctx } => {
-            visitor.visit_ident(id);
+        ExprKind::Name { ctx, .. } => {
             visitor.visit_expr_context(ctx);
         }
         ExprKind::List { elts, ctx } => {
@@ -476,13 +456,10 @@ pub fn walk_comprehension<V: Visitor + ?Sized>(visitor: &mut V, comprehension: &
 
 pub fn walk_excepthandler<V: Visitor + ?Sized>(visitor: &mut V, excepthandler: &Excepthandler) {
     match &excepthandler.node {
-        ExcepthandlerKind::ExceptHandler { type_, name, body } => {
+        ExcepthandlerKind::ExceptHandler { type_, body, .. } => {
             if let Some(expr) = type_ {
                 visitor.visit_expr(expr);
             }
-            if let Some(ident) = name {
-                visitor.visit_ident(ident);
-            }
             for stmt in body {
                 visitor.visit_stmt(stmt);
             }
@@ -550,50 +527,34 @@ pub fn walk_pattern<V: Visitor + ?Sized>(visitor: &mut V, pattern: &Pattern) {
                 visitor.visit_pattern(pattern)
             }
         }
-        PatternKind::MatchMapping {
-            keys,
-            patterns,
-            rest,
-        } => {
+        PatternKind::MatchMapping { keys, patterns, .. } => {
             for expr in keys {
                 visitor.visit_expr(expr);
             }
             for pattern in patterns {
                 visitor.visit_pattern(pattern);
             }
-            if let Some(ident) = rest {
-                visitor.visit_ident(ident);
-            }
         }
         PatternKind::MatchClass {
             cls,
             patterns,
-            kwd_attrs,
             kwd_patterns,
+            ..
         } => {
             visitor.visit_expr(cls);
             for pattern in patterns {
                 visitor.visit_pattern(pattern);
             }
-            for ident in kwd_attrs {
-                visitor.visit_ident(ident);
-            }
+
             for pattern in kwd_patterns {
                 visitor.visit_pattern(pattern);
             }
         }
-        PatternKind::MatchStar { name } => {
-            if let Some(ident) = name {
-                visitor.visit_ident(ident)
-            }
-        }
-        PatternKind::MatchAs { pattern, name } => {
+        PatternKind::MatchStar { .. } => {}
+        PatternKind::MatchAs { pattern, .. } => {
             if let Some(pattern) = pattern {
                 visitor.visit_pattern(pattern)
             }
-            if let Some(ident) = name {
-                visitor.visit_ident(ident)
-            }
         }
         PatternKind::MatchOr { patterns } => {
             for pattern in patterns {
@@ -604,22 +565,25 @@ pub fn walk_pattern<V: Visitor + ?Sized>(visitor: &mut V, pattern: &Pattern) {
 }
 
 #[allow(unused_variables)]
-pub fn walk_ident<V: Visitor + ?Sized>(visitor: &mut V, ident: &str) {}
-
-#[allow(unused_variables)]
+#[inline(always)]
 pub fn walk_expr_context<V: Visitor + ?Sized>(visitor: &mut V, expr_context: &ExprContext) {}
 
 #[allow(unused_variables)]
+#[inline(always)]
 pub fn walk_boolop<V: Visitor + ?Sized>(visitor: &mut V, boolop: &Boolop) {}
 
 #[allow(unused_variables)]
+#[inline(always)]
 pub fn walk_operator<V: Visitor + ?Sized>(visitor: &mut V, operator: &Operator) {}
 
 #[allow(unused_variables)]
+#[inline(always)]
 pub fn walk_unaryop<V: Visitor + ?Sized>(visitor: &mut V, unaryop: &Unaryop) {}
 
 #[allow(unused_variables)]
+#[inline(always)]
 pub fn walk_cmpop<V: Visitor + ?Sized>(visitor: &mut V, cmpop: &Cmpop) {}
 
 #[allow(unused_variables)]
+#[inline(always)]
 pub fn walk_alias<V: Visitor + ?Sized>(visitor: &mut V, alias: &Alias) {}