feat(code-graph): capture compact constructor defs and implicit accessors

ajuckel · GitLab · commit b862122f0baa · 2026-06-12T12:53:38.000-07:00
diff --git a/crates/code-graph/src/v2/langs/generic/java.rs b/crates/code-graph/src/v2/langs/generic/java.rs
@@ -59,6 +59,69 @@ fn java_super_types(node: &N<'_>) -> Vec<String> {
     result
 }
 
+/// Extract implicit accessor definitions for record components, only when
+/// the body does not explicitly define a no-arg method that shares a name
+/// with that component.
+fn java_record_accessors(
+    node: &N<'_>,
+    defs: &mut Vec<crate::v2::types::CanonicalDefinition>,
+    scope_stack: &[std::sync::Arc<str>],
+    sep: &'static str,
+) -> bool {
+    if node.kind() != "record_declaration" {
+        return false;
+    }
+    let Some(params) = node.field("parameters") else {
+        return false;
+    };
+    let no_arg_body_methods: Vec<String> = node
+        .field("body")
+        .map(|body| {
+            body.children()
+                .filter(|c| c.kind() == "method_declaration")
+                .filter(|m| {
+                    m.field("parameters").is_none_or(|p| {
+                        !p.children().any(|c| {
+                            matches!(c.kind().as_ref(), "formal_parameter" | "spread_parameter")
+                        })
+                    })
+                })
+                .filter_map(|m| m.field("name").map(|n| n.text().to_string()))
+                .collect()
+        })
+        .unwrap_or_default();
+    for param in params.children() {
+        if param.kind() != "formal_parameter" {
+            continue;
+        }
+        let Some(name) = param.field("name").map(|n| n.text().to_string()) else {
+            continue;
+        };
+        if no_arg_body_methods.contains(&name) {
+            continue;
+        }
+        let return_type = field("type")
+            .inner("type_arguments", "type_identifier")
+            .apply(&param);
+        let fqn = crate::v2::types::Fqn::from_scope(scope_stack, &name, sep);
+        defs.push(crate::v2::types::CanonicalDefinition {
+            definition_type: "Method",
+            kind: DefKind::Method,
+            name,
+            fqn,
+            range: crate::v2::dsl::utils::canonical_range(&crate::utils::node_to_range(&param)),
+            is_top_level: false,
+            metadata: return_type.map(|rt| {
+                Box::new(crate::v2::types::DefinitionMetadata {
+                    return_type: Some(rt),
+                    ..Default::default()
+                })
+            }),
+        });
+    }
+    false
+}
+
 impl DslLanguage for JavaDsl {
     fn name() -> &'static str {
         "java"
@@ -72,6 +135,7 @@ impl DslLanguage for JavaDsl {
         LanguageHooks {
             return_kinds: &["return_statement"],
             adopt_sibling_refs: &["marker_annotation", "annotation"],
+            on_scope: Some(java_record_accessors),
             ..LanguageHooks::default()
         }
     }
@@ -106,6 +170,7 @@ impl DslLanguage for JavaDsl {
                         .type_annotation(field("type").inner("type_arguments", "type_identifier")),
                 ),
             scope("constructor_declaration", "Constructor").def_kind(DefKind::Constructor),
+            scope("compact_constructor_declaration", "Constructor").def_kind(DefKind::Constructor),
             scope("method_declaration", "Method")
                 .def_kind(DefKind::Method)
                 .metadata(
@@ -443,6 +508,87 @@ mod tests {
         }
     }
 
+    #[test]
+    fn record_compact_constructor() {
+        let result = parse(
+            "public record Bounds(int lo, int hi) {\n    public Bounds {\n        if (lo > hi) throw new IllegalArgumentException(\"lo > hi\");\n    }\n}\n",
+        )
+        .unwrap();
+        let ctor = result
+            .definitions
+            .iter()
+            .find(|d| d.kind == DefKind::Constructor)
+            .expect("compact constructor should be extracted");
+        assert_eq!(ctor.name, "Bounds");
+        assert_eq!(ctor.fqn.to_string(), "Bounds.Bounds");
+    }
+
+    #[test]
+    fn record_implicit_accessors() {
+        let result = parse("public record Point(int x, int y) {}\n").unwrap();
+        let accessors: Vec<_> = result
+            .definitions
+            .iter()
+            .filter(|d| d.kind == DefKind::Method)
+            .collect();
+        assert_eq!(accessors.len(), 2);
+        assert_eq!(accessors[0].fqn.to_string(), "Point.x");
+        assert_eq!(accessors[1].fqn.to_string(), "Point.y");
+        assert_eq!(
+            accessors[0].metadata.as_ref().unwrap().return_type,
+            Some("int".to_string())
+        );
+    }
+
+    #[test]
+    fn record_parameterized_overload_does_not_suppress_accessor() {
+        let result = parse(
+            "public record Circle(int radius) {\n    public int radius(int base) {\n        return this.radius() + base;\n    }\n}\n",
+        )
+        .unwrap();
+        let mut lines: Vec<_> = result
+            .definitions
+            .iter()
+            .filter(|d| d.name == "radius" && d.kind == DefKind::Method)
+            .map(|d| d.range.start.line)
+            .collect();
+        lines.sort_unstable();
+        // Line 0 is the synthetic accessor anchored to the component; line 1
+        // is the explicit radius(int) overload, which must not suppress it.
+        assert_eq!(lines, [0, 1]);
+    }
+
+    #[test]
+    fn record_zero_arg_override_beside_overload_suppresses_accessor() {
+        let result = parse(
+            "public record Circle(int radius) {\n    public int radius() {\n        return 0;\n    }\n    public int radius(int base) {\n        return this.radius() + base;\n    }\n}\n",
+        )
+        .unwrap();
+        let mut lines: Vec<_> = result
+            .definitions
+            .iter()
+            .filter(|d| d.name == "radius" && d.kind == DefKind::Method)
+            .map(|d| d.range.start.line)
+            .collect();
+        lines.sort_unstable();
+        assert_eq!(lines, [1, 4], "both defs must be the explicit declarations");
+    }
+
+    #[test]
+    fn record_explicit_accessor_override_not_duplicated() {
+        let result = parse(
+            "public record Wrapped(int raw) {\n    public int raw() {\n        return raw < 0 ? 0 : raw;\n    }\n}\n",
+        )
+        .unwrap();
+        let raws: Vec<_> = result
+            .definitions
+            .iter()
+            .filter(|d| d.name == "raw" && d.kind == DefKind::Method)
+            .collect();
+        assert_eq!(raws.len(), 1);
+        assert_ne!(raws[0].range.start.line, 0, "must be the explicit override");
+    }
+
     #[test]
     fn imports_extracted() {
         let result =
diff --git a/crates/integration-tests-codegraph/fixtures/java/enums.yaml b/crates/integration-tests-codegraph/fixtures/java/enums.yaml
@@ -9,8 +9,9 @@ name: "Java enums — constants, constructor, fields, methods, interface impleme
 #
 # Known gap (not asserted here): the compiler-synthesised enum members values(),
 # valueOf(), and ordinal() are not present in the source AST, so they are not
-# indexed — only members written in source are extracted. This mirrors the
-# synthesised-accessor gap documented in fixtures/java/records.yaml (#846).
+# indexed — only members written in source are extracted. Record component
+# accessors get synthetic definitions from the java.rs on_scope hook; enum
+# members have no equivalent yet.
 
 fixtures:
   - path: com/example/enums/Describable.java
diff --git a/crates/integration-tests-codegraph/fixtures/java/records.yaml b/crates/integration-tests-codegraph/fixtures/java/records.yaml
@@ -1,15 +1,12 @@
 name: "Java 14+ records — definitions, members, call resolution, and pattern matching"
 
-# Gaps confirmed by this fixture — tracked in #846, do not expand this issue to fix them:
-#   - compact_constructor_declaration has no scope rule → compact constructors not indexed.
-#     Follow-up: add scope("compact_constructor_declaration", "Constructor") to java.rs.
-#   - Implicit accessor methods generated from record components (e.g. x(), y()) are
-#     compiler-synthesised and absent from the source AST → not indexed.
-# Additional gap tracked in #851:
+# Remaining gaps confirmed by this fixture:
+#   - Implicit equals/hashCode/toString on records are compiler-synthesised and
+#     not indexed; the java.rs on_scope hook only synthesises component accessors.
+# Gap tracked in #851:
 #   - Java 21 record patterns (record_pattern nodes) produce no edges at all:
 #     neither the type reference (instanceof Point(int x, int y)) nor accessor
-#     calls for destructured components. Accessor-call emission for destructured
-#     components additionally depends on implicit accessors existing (#846).
+#     calls for destructured components.
 
 fixtures:
   - path: com/example/records/Measurable.java
@@ -276,6 +273,15 @@ tests:
       - { row_count: 1 }
       - { row: { name: "Range" } }
 
+  - name: "Bounds compact constructor is extracted"
+    query: |
+      MATCH (cls:Definition)-[:DefinitionToDefinition]->(m:Definition)
+      WHERE cls.fqn = 'com.example.records.Bounds' AND m.name = 'Bounds'
+        AND m.definition_type = 'Constructor'
+      RETURN m.fqn AS fqn
+    assert:
+      - { row_count: 1 }
+
   # ── Methods ───────────────────────────────────────────────────────
 
   - name: "Custom method length() in Range is extracted"
@@ -296,6 +302,20 @@ tests:
       - { row_count: 1 }
       - { row: { type: "Method" } }
 
+  - name: "Implicit accessors x() and y() are synthesised for Point components"
+    query: |
+      MATCH (cls:Definition)-[:DefinitionToDefinition]->(m:Definition)
+      WHERE cls.fqn = 'com.example.records.Point'
+        AND m.definition_type = 'Method'
+      RETURN m.name AS name, m.start_line AS line
+      ORDER BY name
+    assert:
+      # Line 4 is the record declaration: synthetic accessors anchor to
+      # their component's range.
+      - { row_count: 2 }
+      - { row: { name: "x", line: 4 } }
+      - { row: { name: "y", line: 4 } }
+
   # ── Containment edges ─────────────────────────────────────────────
 
   - name: "Range record defines its canonical constructor"
@@ -428,6 +448,33 @@ tests:
     assert:
       - { row_count: 1 }
 
+  - name: "PointUser.describe() calls implicit accessors Point.x and Point.y"
+    query: |
+      MATCH (caller:Definition)-[e:DefinitionToDefinition]->(callee:Definition)
+      WHERE caller.fqn = 'com.example.records.PointUser.describe'
+        AND e.edge_kind = 'Calls'
+        AND callee.name IN ['x', 'y']
+      RETURN callee.fqn AS callee
+      ORDER BY callee
+    assert:
+      - { row_count: 2 }
+      - { row: { callee: "com.example.records.Point.x" } }
+      - { row: { callee: "com.example.records.Point.y" } }
+
+  - name: "ShapeUser.area() implicit accessor calls on instanceof-bound variables"
+    query: |
+      MATCH (caller:Definition)-[e:DefinitionToDefinition]->(callee:Definition)
+      WHERE caller.fqn = 'com.example.records.ShapeUser.area'
+        AND e.edge_kind = 'Calls'
+        AND callee.name IN ['radius', 'width', 'height']
+      RETURN DISTINCT callee.fqn AS callee
+      ORDER BY callee
+    assert:
+      - { row_count: 3 }
+      - { row: { callee: "com.example.records.Circle.radius" } }
+      - { row: { callee: "com.example.records.Rectangle.height" } }
+      - { row: { callee: "com.example.records.Rectangle.width" } }
+
   # ── Explicit overrides of implicit members ────────────────────────
 
   - name: "Explicit accessor override is a single Method definition"
@@ -491,18 +538,6 @@ tests:
 
   # ── Gaps (severity: warning — see header comment) ─────────────────
 
-  - name: "GAP: Point accessor methods defined"
-    severity: warning
-    query: |
-      MATCH (cls:Definition)-[:DefinitionToDefinition]->(m:Definition)
-      WHERE cls.fqn = 'com.example.records.Point'
-        AND m.definition_type = 'Method'
-      RETURN m.name AS name
-      ORDER BY name
-    assert:
-      - { row: { name: "x" } }
-      - { row: { name: "y" } }
-
   - name: "GAP: implicit equals/hashCode/toString defined on Point"
     severity: warning
     query: |
@@ -516,42 +551,6 @@ tests:
       - { row: { name: "hashCode" } }
       - { row: { name: "toString" } }
 
-  - name: "GAP: PointUser.describe() calls Point.x and Point.y accessors"
-    severity: warning
-    query: |
-      MATCH (caller:Definition)-[e:DefinitionToDefinition]->(callee:Definition)
-      WHERE caller.fqn = 'com.example.records.PointUser.describe'
-        AND e.edge_kind = 'Calls'
-      RETURN callee.name AS callee
-      ORDER BY callee
-    assert:
-      - { row: { callee: "x" } }
-      - { row: { callee: "y" } }
-
-  - name: "GAP: ShapeUser.area() accessor calls on instanceof-bound variables"
-    severity: warning
-    query: |
-      MATCH (caller:Definition)-[e:DefinitionToDefinition]->(callee:Definition)
-      WHERE caller.fqn = 'com.example.records.ShapeUser.area'
-        AND e.edge_kind = 'Calls'
-        AND callee.name IN ['radius', 'width', 'height']
-      RETURN callee.name AS callee
-      ORDER BY callee
-    assert:
-      - { row: { callee: "height" } }
-      - { row: { callee: "radius" } }
-      - { row: { callee: "width" } }
-
-  - name: "GAP: Bounds compact constructor is extracted"
-    severity: warning
-    query: |
-      MATCH (cls:Definition)-[:DefinitionToDefinition]->(m:Definition)
-      WHERE cls.fqn = 'com.example.records.Bounds' AND m.name = 'Bounds'
-        AND m.definition_type IN ['Constructor', 'Method']
-      RETURN m.fqn AS fqn
-    assert:
-      - { row_count: 1 }
-
   - name: "GAP: instanceof record pattern emits Point type reference"
     severity: warning
     query: |
