@@ -100,6 +100,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   file's grammar, interpolations kept, in every language with one; the
   lexer and its special cases (`//` as floor division, a Rust lifetime,
   `*` block-comment lines) are gone (#506).
+- A removed definition is one the file declared at the base and does not
+  declare at the head, both read off the grammar. Read off removed lines by
+  regex, a Rust tail expression `Err("zero")` became a removed member named
+  `Err` with every `Err(` in the crate as its callers, a bare `int(text)` in
+  a Python method a removed `int`, and a private function next to an
+  `impl` a removed API (#515, #458). A member is as public as the class or
+  interface it sits in, by nesting, not by the nearest class above it.
 - A dependency bump is a change: impact names the lock files a range
   changes (`lockfile_changes`) and never answers "No changes to analyse" for
   them (#495).
 
@@ -2393,10 +2393,16 @@ pub fn build_impact(
                 })
         };
         let kotlin_removed = removed_kotlin(state, &kotlin, &base, head_rev.as_deref());
-        for (sym, contract) in
-            removed_definitions(state, &defined, head_rev.as_deref(), &in_a_hunk, &binds_to)
-                .into_iter()
-                .chain(kotlin_removed)
+        for (sym, contract) in removed_definitions(
+            state,
+            &defined,
+            &base,
+            head_rev.as_deref(),
+            &in_a_hunk,
+            &binds_to,
+        )
+        .into_iter()
+        .chain(kotlin_removed)
         {
             if let Some(c) = contract {
                 contracts.push(c);
@@ -2521,101 +2527,12 @@ pub fn build_impact(
     }
 }
 
-/// A declaration a removed line spells: `function f(`, `def f(`, `fn f(`,
-/// `class C`, `interface I`, `func (r T) f(`, `def self.f`, `const f = () =>`.
-static REMOVED_DECLARATION: once_cell::sync::Lazy<regex::Regex> = once_cell::sync::Lazy::new(
-    || {
-        regex::Regex::new(
-        r"^\s*((?:(?:export|default|pub(?:\([^)]*\))?|public|private|protected|static|async|abstract|readonly|override|declare)\s+)*)(?:(?:function\*?|def|fn|func|class|interface|type|enum|struct|trait)\s+(?:\([^)]*\)\s*)?(?:self\.)?([A-Za-z_$][\w$]*)|(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*(?::[^=]*)?=>|[A-Za-z_$][\w$]*\s*=>))",
-    )
-    .expect("removed declaration regex")
-    },
-);
-
-/// A member a removed line declares inside a class or an interface:
-/// `m?(): void;`, `m(x: T) {`, `async m() {`.
-static REMOVED_MEMBER: once_cell::sync::Lazy<regex::Regex> = once_cell::sync::Lazy::new(|| {
-    regex::Regex::new(
-        r"^\s*(?:(?:public|private|protected|static|async|abstract|readonly|override|get|set)\s+)*([A-Za-z_$][\w$]*)\??\s*(?:<[^>]*>)?\s*\([^)]*\)\s*(?::[^;{=]*)?\s*[;{]?\s*$",
-    )
-    .expect("removed member regex")
-});
-
-/// The member a class-body line declares. `notify(x);` with no modifier
-/// and no return type is a call statement inside a method body, not a
-/// declaration: read as one, deleting the call reported a removed API.
-fn member_declared(line: &str) -> Option<&str> {
-    let name = REMOVED_MEMBER.captures(line)?.get(1)?.as_str();
-    let code = line.trim();
-    let modified = code
-        .split_whitespace()
-        .next()
-        .is_some_and(|w| MEMBER_MODIFIERS.contains(&w));
-    let call = code
-        .strip_suffix(';')
-        .is_some_and(|c| c.trim_end().ends_with(')'));
-    (modified || !call).then_some(name)
-}
-
-const MEMBER_MODIFIERS: &[&str] = &[
-    "public",
-    "private",
-    "protected",
-    "static",
-    "async",
-    "abstract",
-    "readonly",
-    "override",
-    "declare",
-    "get",
-    "set",
-];
-
 /// Directory names every project has: naming one says nothing about which.
 const GENERIC_DIRECTORIES: &[&str] = &[
     "src", "main", "java", "kotlin", "scala", "lib", "test", "tests", "app", "pkg", "internal",
     "cmd", "include", "source", "sources",
 ];
 
-// Every supported language's `keyword (…) {`: a control statement removed
-// from a body reads like a method header.
-const NOT_MEMBER_NAMES: &[&str] = &[
-    "if",
-    "for",
-    "while",
-    "switch",
-    "catch",
-    "match",
-    "when",
-    "try",
-    "synchronized",
-    "using",
-    "lock",
-    "fixed",
-    "foreach",
-    "elseif",
-    "return",
-    "function",
-    "super",
-    "constructor",
-    "await",
-    "new",
-    "typeof",
-    "self",
-    "cls",
-    "this",
-];
-
-fn declared_name(line: &str) -> Option<(&str, bool)> {
-    let c = REMOVED_DECLARATION.captures(line)?;
-    let prefix = c.get(1).map_or("", |m| m.as_str());
-    let name = c.get(2).or_else(|| c.get(3))?.as_str();
-    Some((
-        name,
-        prefix.contains("export") || prefix.contains("pub ") || prefix.trim() == "pub",
-    ))
-}
-
 /// Definitions the change removed and nothing at the head defines again,
 /// with the lines outside the diff that still name them (#367). They have
 /// no fragment at the head, so the callers graph never reaches them: an
@@ -2772,90 +2689,85 @@ fn removed_kotlin(
 fn removed_definitions(
     state: &ScoredState,
     defined: &FxHashMap<&str, FxHashSet<String>>,
+    base: &str,
     head: Option<&str>,
     in_a_hunk: &dyn Fn(&FragmentId) -> bool,
     binds_to: &dyn Fn(&str, &str, &str, &str) -> bool,
 ) -> Vec<(ChangedSymbol, Option<Contract>)> {
-    let mut removed: Vec<(String, &crate::change_class::HunkText, bool)> = Vec::new();
+    // Read off the grammar, the file at the base against the file at the
+    // head: a removed definition is one the base declared and the head does
+    // not. Read off removed lines by regex, a match arm became a removed
+    // member named `Err`, a call statement a removed API, and an indented
+    // line of a free function a member of the nearest class above it (#515).
+    let old_path_of: FxHashMap<&str, &str> = state
+        .renamed_files
+        .iter()
+        .map(|(old, new)| (new.as_str(), old.as_str()))
+        .collect();
+    let mut seen: FxHashSet<&str> = FxHashSet::default();
+    // (name, path, its lines at the base, exported)
+    let mut removed: Vec<(String, String, String, bool)> = Vec::new();
     for h in &state.hunk_texts {
-        // Kotlin's removals come from its facts (`removed_kotlin`): a call
-        // statement there ends with no `;` and read as a declaration.
-        if !is_code_file(&h.path) || is_kotlin(&h.path) {
+        // Kotlin's removals come from its facts (`removed_kotlin`).
+        if h.removed.is_empty()
+            || !is_code_file(&h.path)
+            || is_kotlin(&h.path)
+            || !seen.insert(h.path.as_str())
+        {
             continue;
         }
-        let (anchor, _) = h.new_range();
-        let classes: Vec<&Fragment> = state
-            .all_fragments
-            .iter()
-            .filter(|f| {
-                f.kind.is_container() && f.start_line() <= anchor && rel(state, f.path()) == h.path
-            })
-            .collect();
-        // As in `enclosing_class`: a class may be fragmented as its header
-        // alone, so an indented line belongs to the nearest shallower class
-        // above it.
-        let container_of = |line: &str| {
-            let own = indent_of(line);
-            classes
-                .iter()
-                .copied()
-                .filter(|c| c.end_line() >= anchor)
-                .min_by_key(|c| c.line_count())
-                .or_else(|| {
-                    (own > 0)
-                        .then(|| {
-                            classes
-                                .iter()
-                                .copied()
-                                .filter(|c| indent_of(&c.content) < own)
-                                .max_by_key(|c| c.start_line())
-                        })
-                        .flatten()
+        let old_path = old_path_of.get(h.path.as_str()).copied().unwrap_or(&h.path);
+        let before = read_or_note(
+            state,
+            crate::git::show_file_at_revision(&state.root_dir, base, Path::new(old_path)),
+        );
+        let (Some(at_base), Some(at_head)) = (
+            crate::parsers::declarations(old_path, &before),
+            crate::parsers::declarations(
+                &h.path,
+                &state
+                    .run
+                    .source()
+                    .read_to_string(&state.root_dir.join(&h.path))
+                    .unwrap_or_default(),
+            ),
+        ) else {
+            continue;
+        };
+        let still: FxHashSet<&str> = at_head.iter().map(|d| d.name.as_str()).collect();
+        let public = |d: &crate::parsers::Declaration| {
+            let head = d.head.trim_start();
+            is_public(old_path, Some(&d.name), head)
+                || d.container.is_some_and(|c| {
+                    !head.starts_with("private")
+                        && !head.starts_with("protected")
+                        && !head.starts_with('#')
+                        && is_public(
+                            old_path,
+                            Some(&at_base[c].name),
+                            at_base[c].head.trim_start(),
+                        )
                 })
         };
-        let readded: FxHashSet<String> = h
-            .added
-            .iter()
-            .filter_map(|l| {
-                declared_name(l)
-                    .map(|(n, _)| n)
-                    .or_else(|| container_of(l).and_then(|_| member_declared(l)))
-                    .map(str::to_string)
-            })
-            .collect();
-        for line in &h.removed {
-            let container = container_of(line);
-            let (name, exported) = if let Some((n, exported)) = declared_name(line) {
-                (Some(n), exported)
-            } else if let Some(n) = container.and_then(|_| member_declared(line)) {
-                let exported = container.is_some_and(|f| {
-                    is_public(
-                        f.path(),
-                        f.symbol_name.as_deref(),
-                        without_decorators(&f.content),
-                    )
-                });
-                (Some(n), exported)
-            } else {
-                (None, false)
-            };
-            let Some(name) = name.filter(|n| {
-                n.len() >= 3
-                    && !NOT_MEMBER_NAMES.contains(n)
-                    && !defined.get(n).is_some_and(|at| at.contains(&h.path))
-                    && !readded.contains(*n)
-            }) else {
+        for d in &at_base {
+            if d.name.len() < 3
+                || still.contains(d.name.as_str())
+                || removed.iter().any(|(n, _, _, _)| *n == d.name)
+            {
                 continue;
-            };
-            if !removed.iter().any(|(n, _, _)| n == name) {
-                removed.push((name.to_string(), h, exported));
             }
+            removed.push((
+                d.name.clone(),
+                h.path.clone(),
+                format!("{}-{}", d.start_line, d.end_line),
+                public(d),
+            ));
         }
     }
     // One grep for every removed name, its lines handed to the names they
     // spell as a word: a deleted 1000-function module ran 1000 greps and
     // outlived the deadline.
-    let names: Vec<String> = removed.iter().map(|(n, _, _)| n.clone()).collect();
+    let names: Vec<String> = removed.iter().map(|(n, _, _, _)| n.clone()).collect();
     let wanted: FxHashSet<&str> = names.iter().map(String::as_str).collect();
     let mut hits_of: FxHashMap<&str, Vec<(String, u32, String)>> = FxHashMap::default();
     let grepped = read_or_note(
@@ -2884,7 +2796,7 @@ fn removed_definitions(
         holders.entry(rel(state, f.path())).or_default().push(f);
     }
     let mut out = Vec::new();
-    for (name, h, exported) in removed {
+    for (name, path_removed, lines, exported) in removed {
         if !state.run.check() {
             break;
         }
@@ -2923,9 +2835,9 @@ fn removed_definitions(
             }
             if let Some(at) = moved_to {
                 let reaches_new = if bindings::lang_of(&path).is_some() {
-                    !binds_to(&path, &text, &name, &h.path)
+                    !binds_to(&path, &text, &name, &path_removed)
                 } else {
-                    at.iter().any(|f| qualified_by(&text, f)) && !qualified_by(&text, &h.path)
+                    at.iter().any(|f| qualified_by(&text, f)) && !qualified_by(&text, &path_removed)
                 };
                 if reaches_new {
                     continue;
@@ -2951,12 +2863,13 @@ fn removed_definitions(
                 .filter(|f| f.start_line() <= line && f.end_line() >= line)
                 .min_by_key(|f| f.line_count())
                 .copied();
-            // A line declaring the name is where it went (a move), never a
+            // The line declaring the name is where it went (a move), never a
             // caller of the removed definition; a method of the same name
             // that delegates to it still is one.
-            if holder.is_some_and(|f| in_a_hunk(&f.id) && f.line_count() <= 1)
-                || declared_name(&text).is_some_and(|(n, _)| n == name)
-            {
+            if holder.is_some_and(|f| {
+                (in_a_hunk(&f.id) && f.line_count() <= 1)
+                    || (f.symbol_name.as_deref() == Some(name.as_str()) && f.start_line() == line)
+            }) {
                 continue;
             }
             let next = code[at + name.len()..].trim_start();
@@ -2980,19 +2893,14 @@ fn removed_definitions(
             });
         }
         let callers = merge_by_symbol(callers);
-        let lines = format!(
-            "{}-{}",
-            h.old_start,
-            h.old_start + h.old_len.saturating_sub(1)
-        );
         let contract = exported.then(|| Contract {
-            path: h.path.clone(),
+            path: path_removed.clone(),
             symbol: Some(name.clone()),
             kind: "removed_api",
         });
         out.push((
             ChangedSymbol {
-                path: h.path.clone(),
+                path: path_removed,
                 symbol: Some(name),
                 lines,
                 kind: "removed".to_string(),
 
@@ -27,7 +27,7 @@ static STRATEGIES: Lazy<Vec<Box<dyn FragmentationStrategy>>> = Lazy::new(|| {
 
 pub(crate) use tree_sitter_strategy::{has_grammar, parse_tree};
 
-pub use tree_sitter_strategy::{ParseOutcome, code_only};
+pub use tree_sitter_strategy::{Declaration, ParseOutcome, code_only, declarations};
 
 /// Why a code file's definitions were not all read (#454): `no_grammar` when
 /// this build has no grammar for its language, `parse_timeout` when the