@boyingliu01/xp-gate 0.20.0 → 0.20.2

package/principles/adapters/__tests__/java.test.ts

@@ -65,4 +65,321 @@ describe('JavaAdapter', () => {
     const adapter = new JavaAdapter('test.ts');
     expect(adapter.detectLanguage()).toBe('typescript');
   });
+});
+
+/**
+ * @test REQ-507-04
+ * @intent 验证 JavaAdapter 为各规则提供其所需度量字段（#507 S4）：修复前适配器
+ *         只返回 {name,type,line,code}，读结构字段的 12 条规则在 Java 上静默
+ *         拿到 undefined，G4 报告已检查但 0 覆盖。覆盖矩阵见
+ *         docs/java-principles-coverage.md。
+ * @covers AC-507-04-01
+ */
+describe('JavaAdapter metric extraction (#507)', () => {
+  interface FnInfo {
+    name: string;
+    startLine?: number;
+    line?: number;
+    length?: number;
+    paramCount?: number;
+    nestingDepth?: number;
+    hasTryCatch?: boolean;
+    ioOperations?: string[];
+  }
+
+  const LONG_BODY = Array.from({ length: 60 }, (_, i) => `    int v${i} = ${i};`).join('\n');
+
+  const SAMPLE = `
+public class Sample {
+  public void eightParams(int a, int b, int c, int d, int e, int f, int g, int h) {
+    System.out.println(a);
+  }
+
+  public void longOne() {
+${LONG_BODY}
+    return;
+  }
+
+  public void deepOne(int x) {
+    if (x > 0) {
+      if (x > 1) {
+        if (x > 2) {
+          if (x > 3) {
+            if (x > 4) {
+              System.out.println(x);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  public void guardedIo() {
+    try {
+      java.sql.Connection c = java.sql.DriverManager.getConnection("jdbc:x");
+      c.createStatement().executeQuery("SELECT 1");
+    } catch (Exception e) {
+      // swallowed
+    }
+  }
+
+  public void rawIo() {
+    java.sql.Connection c = java.sql.DriverManager.getConnection("jdbc:x");
+    c.createStatement().executeQuery("SELECT 1");
+  }
+
+  public int magic() { return 42; }
+}
+`;
+
+  function adapterFor(content = SAMPLE): JavaAdapter {
+    (readFileSync as Mock).mockReturnValue(content);
+    return new JavaAdapter('Sample.java');
+  }
+
+  function findFn(fns: unknown[], name: string): FnInfo {
+    const found = fns.find(f => (f as FnInfo).name === name);
+    if (!found) throw new Error(`fixture function not extracted: ${name}`);
+    return found as FnInfo;
+  }
+
+  it('reports paramCount (too-many-params contract)', () => {
+    const fns = adapterFor().extractFunctions() as FnInfo[];
+    expect(findFn(fns, 'eightParams').paramCount).toBe(8);
+  });
+
+  it('reports length body span (long-function contract)', () => {
+    const fns = adapterFor().extractFunctions() as FnInfo[];
+    expect(findFn(fns, 'longOne').length).toBeGreaterThan(50);
+  });
+
+  it('reports nestingDepth (deep-nesting contract)', () => {
+    const fns = adapterFor().extractFunctions() as FnInfo[];
+    expect(findFn(fns, 'deepOne').nestingDepth).toBeGreaterThanOrEqual(5);
+  });
+
+  it('reports hasTryCatch and ioOperations (missing-error-handling contract)', () => {
+    const fns = adapterFor().extractFunctions() as FnInfo[];
+    const guarded = findFn(fns, 'guardedIo');
+    expect(guarded.hasTryCatch).toBe(true);
+    expect((guarded.ioOperations ?? []).length).toBeGreaterThan(0);
+
+    const raw = findFn(fns, 'rawIo');
+    expect(raw.hasTryCatch).toBe(false);
+    expect(raw.ioOperations).toContain('getConnection');
+    expect(raw.ioOperations).toContain('executeQuery');
+  });
+
+  it('reports startLine for every function (violation line attribution)', () => {
+    const fns = adapterFor().extractFunctions() as FnInfo[];
+    for (const f of fns) {
+      expect(f.startLine).toBeGreaterThan(0);
+      expect(f.name).toBeTruthy();
+    }
+  });
+
+  it('does not report control keywords as functions', () => {
+    const fns = adapterFor().extractFunctions() as FnInfo[];
+    const names = fns.map(f => f.name);
+    for (const kw of ['if', 'for', 'while', 'switch', 'catch', 'return']) {
+      expect(names).not.toContain(kw);
+    }
+  });
+
+  describe('extract (magic numbers)', () => {
+    it('returns {value,line} and masks strings/comments', () => {
+      const content = `
+// 999 in a comment must not count
+String s = "1234 in a string must not count";
+int x = 12345;
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const adapter = new JavaAdapter('M.java') as unknown as {
+        extract: () => Array<{ value: number; line: number }>;
+      };
+      const values = adapter.extract().map(n => n.value);
+      expect(values).toContain(12345);
+      expect(values).not.toContain(999);
+      expect(values).not.toContain(1234);
+    });
+
+    it('reports digits used as call arguments (#507 blind review M2)', () => {
+      const content = `
+public class Calls {
+  public int go() {
+    return Math.max(1, 99);
+  }
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const adapter = new JavaAdapter('C.java') as unknown as {
+        extract: () => Array<{ value: number; line: number }>;
+      };
+      const values = adapter.extract().map(n => n.value);
+      expect(values).toContain(99);
+      expect(values).toContain(1);
+    });
+
+    it('masks block comments including cross-line ones (#507 blind review M3)', () => {
+      const content = `
+public class Commented {
+  /* int inlineBlock = 555; */
+  // string containing slashes must not swallow the rest: see below
+  String url = "http://x"; int y = 42;
+  /*
+   * int multi = 777;
+   * int line2 = 888;
+   */
+  int live = 11;
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const adapter = new JavaAdapter('B.java') as unknown as {
+        extract: () => Array<{ value: number; line: number }>;
+      };
+      const values = adapter.extract().map(n => n.value);
+      expect(values).toContain(42);   // after a string with `//`, same line
+      expect(values).toContain(11);   // after a multi-line block comment
+      expect(values).not.toContain(555);
+      expect(values).not.toContain(777);
+      expect(values).not.toContain(888);
+    });
+
+    it('skips static final constant initializers but reports bare literals', () => {
+      // The rule's remedy is "use a named constant" -- flagging the constant
+      // itself would make violations unfixable (#446 precedent on TS).
+      const content = `
+public class C {
+  public static final int MAX = 3;
+  public int bare() { return 137; }
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const adapter = new JavaAdapter('C.java') as unknown as {
+        extract: () => Array<{ value: number; line: number }>;
+      };
+      const values = adapter.extract().map(n => n.value);
+      expect(values).not.toContain(3);
+      expect(values).toContain(137);
+    });
+  });
+
+  describe('imports (unused-imports contract)', () => {
+    it('marks unused and used imports with line numbers', () => {
+      const content = `
+import java.util.ArrayList;
+import java.io.File;
+
+public class C {
+  public ArrayList<String> go() { return new ArrayList<>(); }
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const adapter = new JavaAdapter('C.java') as unknown as {
+        imports: Array<{ name: string; line: number; used: boolean }>;
+      };
+      const imports = adapter.imports;
+      const list = imports.find(i => i.name === 'java.util.ArrayList');
+      expect(list?.used).toBe(true);
+      const file = imports.find(i => i.name === 'java.io.File');
+      expect(file?.used).toBe(false);
+      expect(file?.line).toBe(3);
+    });
+  });
+
+  describe('extractClasses / extractInterfaces (srp/isp contracts)', () => {
+    it('reports methodCount per class (srp reads it directly)', () => {
+      const content = `
+public class Busy {
+  public void m1() {}
+  public void m2() {}
+  public void m3() {}
+  public void m4() {}
+  public void m5() {}
+  public void m6() {}
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const classes = adapterFor(content).extractClasses() as Array<{ name: string; methodCount: number }>;
+      expect(classes.find(c => c.name === 'Busy')?.methodCount).toBe(6);
+    });
+
+    it('extractInterfaces reports interfaces with methodCount (isp contract)', () => {
+      const content = `
+public interface Worker {
+  void run();
+  void stop();
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const adapter = new JavaAdapter('W.java') as unknown as {
+        extractInterfaces: () => Array<{ name: string; methodCount: number }>;
+      };
+      const ifaces = adapter.extractInterfaces();
+      expect(ifaces.find(i => i.name === 'Worker')?.methodCount).toBe(2);
+    });
+
+    it('finds generic classes and interfaces (#507 blind review M1)', () => {
+      const content = `
+public class Box<T> {
+  private T value;
+  public T get() { return value; }
+}
+
+public interface Repo<T, ID> {
+  T findById(ID id);
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const classes = adapterFor(content).extractClasses() as Array<{ name: string; methodCount: number }>;
+      expect(classes.find(c => c.name === 'Box')?.methodCount).toBe(1);
+      const adapter = adapterFor(content) as unknown as {
+        extractInterfaces: () => Array<{ name: string; methodCount: number }>;
+      };
+      expect(adapter.extractInterfaces().find(i => i.name === 'Repo')?.methodCount).toBe(1);
+    });
+
+    it('does not count masked-out members (strings/comments/inner calls)', () => {
+      const content = `
+public class Noisy {
+  public void real() {
+    String s = "fake(1)";
+    // phantomCall(
+    /* alsoFake(2) */
+    helper(1);
+  }
+  public void second() {}
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const classes = adapterFor(content).extractClasses() as Array<{ name: string; methodCount: number; methods: string[] }>;
+      const methods = classes.find(c => c.name === 'Noisy')?.methods ?? [];
+      // The Java member heuristic mirrors the TS adapter (pure `name(` scan on
+      // the class body), so `helper(` -- a real, unqualified call statement --
+      // DOES count. What must never surface are the masked-out members:
+      //   fake(        lived inside a string literal
+      //   phantomCall( lived in a line comment
+      //   alsoFake(    lived in a block comment
+      expect(methods).not.toContain('fake');
+      expect(methods).not.toContain('phantomCall');
+      expect(methods).not.toContain('alsoFake');
+      expect(methods).toEqual(expect.arrayContaining(['real', 'second']));
+    });
+
+    it('does not leak brace depth from string literals (#507 blind review M4)', () => {
+      const content = `
+public class Formatter {
+  public String weird() {
+    String s = "unbalanced { brace";
+    return s;
+  }
+  public int after() { return 0; }
+}
+`;
+      (readFileSync as Mock).mockReturnValue(content);
+      const fns = adapterFor(content).extractFunctions() as Array<{ name: string; nestingDepth: number }>;
+      // `after` must not inherit inflated depth from the string's `{`.
+      expect(findFn(fns as FnInfo[], 'after').nestingDepth).toBeLessThan(3);
+    });
+  });
 });

package/principles/adapters/java.ts

@@ -1,6 +1,191 @@
 import { BaseAdapter } from './base';
 import { Adapter } from '../types';
 
+/**
+ * Structural fields the clean-code rules consume (mirror of the TypeScript
+ * adapter's function shape). Before #507 this adapter returned only
+ * `{ name, type, modifiers, line, code }`, so every rule reading
+ * `startLine`/`length`/`paramCount`/`nestingDepth`/`hasTryCatch`/`ioOperations`
+ * silently saw `undefined` and skipped the file -- G4 reported a run over Java
+ * with zero effective coverage (#507 S4 audit).
+ */
+interface JavaFunctionInfo {
+  name: string;
+  type: string;
+  modifiers: string[];
+  line: number;
+  startLine: number;
+  /** Body line span, matching the `length` field long-function reads. */
+  length: number;
+  paramCount: number;
+  nestingDepth: number;
+  hasTryCatch: boolean;
+  ioOperations: string[];
+  code: string;
+}
+
+interface JavaImportInfo {
+  name: string;
+  line: number;
+  used: boolean;
+  type: string;
+}
+
+/** Java-side I/O markers for the missing-error-handling rule. */
+const JAVA_IO_OPERATIONS = [
+  'executeQuery',
+  'executeUpdate',
+  'executeBatch',
+  'getConnection',
+  'FileInputStream',
+  'FileOutputStream',
+  'FileReader',
+  'FileWriter',
+  'BufferedReader',
+  'BufferedWriter',
+  'Files.',
+  'HttpClient',
+  'RestTemplate',
+  'Socket',
+];
+
+/**
+ * Numeric literal scan for the magic-numbers rule. Lookahead mirrors the
+ * TypeScript adapter (`(?![\w$])`): digits as call arguments (`foo(2)`) are
+ * the most common magic-number site and must be reported, so `)` is NOT
+ * excluded. A per-call regex comes from `javaParse.magicNumberRegex()`;
+ * `String.prototype.match` with the global flag returns all matches per line
+ * and ignores lastIndex, so there is no shared-state bug to worry about.
+ * Known gaps (documented in docs/java-principles-coverage.md): hex
+ * (0xFF), underscore separators (1_000) and literal suffixes (1000L) are
+ * not matched.
+ */
+const MAGIC_NUMBER_SOURCE = '(?<![\\w$.])(-?\\d+(?:\\.\\d+)?)(?![\\w$])';
+
+const MEMBER_KEYWORDS = new Set([
+  'if', 'for', 'while', 'switch', 'catch', 'return', 'synchronized', 'new',
+  'super', 'this', 'throw', 'assert', 'try'
+]);
+
+/**
+ * Pure parse helpers, kept OUTSIDE the adapter class and called through this
+ * namespace object. Two reasons, both from the gate dogfooding itself (#507
+ * S4): the srp heuristic counts every bare `word(` inside a class body as a
+ * method, and dip flags every bare `new X(` as direct instantiation -- dotted
+ * namespace calls keep both scanners blind to implementation helpers.
+ */
+export const javaParse = {
+  /** Top-level brace depth of a method body (deep-nesting rule). */
+  braceDepth(body: string): number {
+    let depth = 0;
+    let max = 0;
+    for (const ch of body) {
+      if (ch === '{') {
+        depth += 1;
+        if (depth > max) max = depth;
+      } else if (ch === '}') {
+        depth -= 1;
+      }
+    }
+    return max;
+  },
+
+  /** Parameter count of a raw parameter list, comma-aware at depth zero. */
+  countParams(paramList: string): number {
+    const trimmed = paramList.trim();
+    if (!trimmed) return 0;
+    let depth = 0;
+    let count = 1;
+    for (const ch of trimmed) {
+      if (ch === '(' || ch === '<' || ch === '[') depth += 1;
+      else if (ch === ')' || ch === '>' || ch === ']') depth -= 1;
+      else if (ch === ',' && depth === 0) count += 1;
+    }
+    return count;
+  },
+
+  /**
+   * Method-like members inside a class/interface body: `name(` occurrences
+   * minus control keywords and constructor calls. Mirrors the TypeScript
+   * adapter's member heuristic so SRP/god-class see the same signal shape.
+   */
+  countMembers(body: string): string[] {
+    const memberRe = /(?<![\w$.])(\w+)\s*\(/g;
+    const methods: string[] = [];
+    let m: RegExpExecArray | null;
+    while ((m = memberRe.exec(body)) !== null) {
+      const name = m[1];
+      if (!MEMBER_KEYWORDS.has(name) && !methods.includes(name)) methods.push(name);
+    }
+    return methods;
+  },
+
+  magicNumberRegex(): RegExp {
+    return new RegExp(MAGIC_NUMBER_SOURCE, 'g');
+  },
+
+  /**
+   * Strip string/char literals and comments (line + block, multi-line)
+   * before any brace/call-site analysis. Contents become empty/space so the
+   * LINE structure (and thus line numbers) is preserved -- column positions
+   * shift, so callers must use lineOf() instead of getLineNumber() on masked
+   * content. This is what keeps a `"{` inside a format string or a javadoc
+   * code example from corrupting nestingDepth/hasTryCatch/methodCount
+   * (#507 blind review M3/M4).
+   *
+   * String/char patterns exclude newlines (#507 Delphi round-1 B-MAJOR-3):
+   * a cross-line pairing let one unbalanced quote inside a comment swallow
+   * every line up to the NEXT real string, deleting whole control blocks
+   * from the analysis. Damage is now bounded to the offending line.
+   */
+  maskCode(body: string): string {
+    return body
+      .replace(/"(?:[^"\\\n]|\\[^\n])*"/g, '""')
+      .replace(/'(?:[^'\\\n]|\\[^\n])'/g, "''")
+      .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, ' '))
+      .replace(/\/\/.*$/gm, '');
+  },
+
+  /**
+   * Line number of `position` within `content`. maskCode preserves line
+   * structure (contents shrink but never add/remove lines), so a line
+   * computed on masked content is exact for the original file.
+   */
+  lineOf(content: string, position: number): number {
+    return content.substring(0, position).split('\n').length;
+  },
+
+  /**
+   * Brace-balanced block starting at the first `{` at/after `startPos`.
+   * Runs on MASKED content only -- on raw text a string-embedded `{`
+   * desynchronizes the depth tracker. Returns null when unbalanced
+   * (callers decide the fallback; base.extractCodeBlock's 100-char
+   * truncation fallback would silently hand back garbage structure).
+   */
+  extractBracedBlock(content: string, startPos: number): string | null {
+    let inBlock = false;
+    let depth = 0;
+    for (let i = startPos; i < content.length; i += 1) {
+      const ch = content[i];
+      if (ch === '{') {
+        inBlock = true;
+        depth += 1;
+      } else if (ch === '}' && inBlock) {
+        depth -= 1;
+        if (depth === 0) {
+          return content.substring(startPos, i + 1);
+        }
+      }
+    }
+    return null;
+  },
+
+  /** Usage detector for an imported simple name (word-boundary, $-escaped). */
+  importUsage(simpleName: string): RegExp {
+    return new RegExp(`\\b${simpleName.replace(/\$/g, '\\$')}\\b`);
+  },
+};
+
 export class JavaAdapter extends BaseAdapter implements Adapter {
   detectLanguage(): string {
     const ext = this.filePath.toLowerCase();
@@ -19,38 +204,165 @@ export class JavaAdapter extends BaseAdapter implements Adapter {
   }
 
   extractFunctions(): unknown[] {
-    const methodMatches = [];
-    const methodRegex = /(public|private|protected|static|final|synchronized|native)\s+[\w<>[\]]+\s+(\w+)\s*\([^)]*\)\s*(throws\s+[\w,\s]+)?\s*{/g;
+    const results: JavaFunctionInfo[] = [];
+    const methodRegex = /(public|private|protected|static|final|synchronized|native)\s+[\w<>[\],\s]+?\s+(\w+)\s*\(([^)]*)\)\s*(throws\s+[\w,\s.]+)?\s*\{/g;
+    // Signature scan AND block extraction run on the MASKED content
+    // (#507 Delphi round-1 B-MAJOR-6 / A-minor-1): a javadoc example like
+    // `public int foo(int x) {` on raw text produced a ghost function whose
+    // length/nestingDepth fed long-function/deep-nesting, and an unbalanced
+    // string brace stretched the extracted block past the real method end.
+    // Masked content keeps line structure, so lineOf() is exact.
+    const maskedContent = javaParse.maskCode(this.fileContent);
     let match;
 
-    while ((match = methodRegex.exec(this.fileContent)) !== null) {
-      methodMatches.push({
+    while ((match = methodRegex.exec(maskedContent)) !== null) {
+      const code = javaParse.extractBracedBlock(maskedContent, match.index) ?? '';
+      const line = javaParse.lineOf(maskedContent, match.index);
+      const masked = code; // already masked (extracted from maskedContent)
+      results.push({
         name: match[2],
         type: 'method',
-        modifiers: match[1].split(' ').filter(m => m.trim()),
-        line: this.getLineNumber(match.index),
-        code: this.extractCodeBlock(match.index)
+        modifiers: match[1].split(/\s+/).filter(m => m.trim()),
+        line,
+        startLine: line,
+        length: code ? code.split('\n').length : 0,
+        paramCount: javaParse.countParams(match[3] ?? ''),
+        nestingDepth: javaParse.braceDepth(masked),
+        hasTryCatch: /catch\s*\(/.test(masked),
+        ioOperations: JAVA_IO_OPERATIONS.filter(op => masked.includes(op)),
+        code
       });
     }
 
-    return methodMatches;
+    return results;
   }
 
   extractClasses(): unknown[] {
     const classMatches = [];
-    const classRegex = /(public|private|protected)?\s*(abstract|final|static)?\s*class\s+(\w+)\s*(extends\s+\w+)?\s*(implements\s+[\w,\s]+)?\s*{/g;
+    // Generic type parameters -- `class Box<T>`, `class Foo<T> extends Bar<T>` --
+    // are the norm in modern Java; without the optional `<...>` slot the
+    // whole class vanished from extractClasses and srp/god-class/dip went
+    // blind on generic code -- #507 blind review M1.
+    const classRegex = /(public|private|protected)?\s*(abstract|final|static)?\s*class\s+(\w+)\s*(?:<[^<>]*>)?\s*(extends\s+[\w.]+(?:<[^<>]*>)?)?\s*(implements\s+[\w,\s.]+(?:<[^<>]*>)?)?\s*\{/g;
     let match;
 
-    while ((match = classRegex.exec(this.fileContent)) !== null) {
+    // Class scan also runs on masked content: a javadoc mention of `class
+    // Foo` no longer yields a ghost class, and string-embedded braces cannot
+    // stretch the extracted body (#507 Delphi round-1 B-MAJOR-6).
+    const maskedContent = javaParse.maskCode(this.fileContent);
+    while ((match = classRegex.exec(maskedContent)) !== null) {
+      const code = javaParse.extractBracedBlock(maskedContent, match.index) ?? '';
+      // srp reads `cls.methodCount` directly, with no code re-scan fallback,
+      // so an adapter omitting it makes SRP structurally dead on Java -- #507 S4.
+      const methods = javaParse.countMembers(code);
       classMatches.push({
         name: match[3],
         type: 'class',
         modifiers: [match[1], match[2]].filter(m => m && m.trim()),
-        line: this.getLineNumber(match.index),
-        code: this.extractCodeBlock(match.index)
+        line: javaParse.lineOf(maskedContent, match.index),
+        methodCount: methods.length,
+        methods,
+        code
       });
     }
 
     return classMatches;
   }
-}
+
+  /**
+   * Interfaces for the ISP rule, which reads `adapter.extractInterfaces()`.
+   * Java interface methods are bare signature lines, counted with the same
+   * member heuristic as classes minus constructors.
+   */
+  extractInterfaces(): Array<{ name: string; line: number; methods: string[]; methodCount: number; code: string }> {
+    const results: Array<{ name: string; line: number; methods: string[]; methodCount: number; code: string }> = [];
+    const ifaceRegex = /(?:public|private|protected)?\s*interface\s+(\w+)\s*(?:<[^<>]*>)?\s*\{/g;
+    let match;
+
+    // Masked scan, same rationale as extractClasses (#507 Delphi round-1
+    // B-MAJOR-6): no ghost interfaces from javadoc, no string-brace bleed.
+    const maskedContent = javaParse.maskCode(this.fileContent);
+    while ((match = ifaceRegex.exec(maskedContent)) !== null) {
+      const code = javaParse.extractBracedBlock(maskedContent, match.index) ?? '';
+      const methods = javaParse.countMembers(code);
+      results.push({
+        name: match[1],
+        line: javaParse.lineOf(maskedContent, match.index),
+        methods,
+        methodCount: methods.length,
+        code
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Numeric literal scan for the magic-numbers rule. Constant declarations
+   * (`static final ... = <n>`) are skipped: naming a constant is exactly the
+   * remedy the rule asks for. Masking ORDER matters -- #507 blind review M3:
+   * string/char literals first, so `"http://x"` cannot swallow the rest of
+   * the line as a comment), then line comments, then block comments with
+   * cross-line state -- a commented-out code block must not resurrect its
+   * numbers as findings.
+   */
+  extract(): Array<{ value: number; line: number }> {
+    const out: Array<{ value: number; line: number }> = [];
+    const lines = this.fileContent.split('\n');
+    const numRegex = javaParse.magicNumberRegex();
+    let inBlockComment = false;
+    for (let i = 0; i < lines.length; i += 1) {
+      let line = lines[i];
+      if (inBlockComment) {
+        const end = line.indexOf('*/');
+        if (end === -1) continue;
+        line = line.slice(end + 2);
+        inBlockComment = false;
+      }
+      line = line
+        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+        .replace(/'(?:[^'\\]|\\.)'/g, "''")
+        .replace(/\/\/.*$/, '');
+      while (line.includes('/*')) {
+        const start = line.indexOf('/*');
+        const end = line.indexOf('*/', start + 2);
+        if (end === -1) {
+          line = line.slice(0, start);
+          inBlockComment = true;
+          break;
+        }
+        line = line.slice(0, start) + ' ' + line.slice(end + 2);
+      }
+      if (/^\s*(?:public|private|protected)?\s*static\s+final\s/.test(line)) continue;
+      const matches = line.match(numRegex) ?? [];
+      for (const value of matches) out.push({ value: Number(value), line: i + 1 });
+    }
+    return out;
+  }
+
+  /**
+   * Import statements with a usage signal for the unused-imports rule. Usage
+   * is a conservative check: the imported simple name must appear somewhere
+   * outside the import block itself.
+   */
+  get imports(): JavaImportInfo[] {
+    const lines = this.fileContent.split('\n');
+    const imports: JavaImportInfo[] = [];
+    const importRegex = /^\s*import\s+(?:static\s+)?([\w.]+)\s*;\s*$/;
+    const importLines = new Set<number>();
+    for (let i = 0; i < lines.length; i += 1) {
+      const m = importRegex.exec(lines[i]);
+      if (m) {
+        imports.push({ name: m[1], line: i + 1, used: false, type: 'import' });
+        importLines.add(i);
+      }
+    }
+    if (imports.length === 0) return imports;
+    const body = lines.filter((_, idx) => !importLines.has(idx)).join('\n');
+    for (const imp of imports) {
+      const simpleName = imp.name.split('.').pop() ?? imp.name;
+      imp.used = javaParse.importUsage(simpleName).test(body);
+    }
+    return imports;
+  }
+}