Function synthesizeLombokMembers

src/extraction/languages/java.ts:118–251

* Synthesize the members Lombok generates at compile time. Covers the common, * mechanical annotations: * * @Getter / @Setter (class- or field-level) → getX()/isX(), setX() * @Data → getters + setters (non-final) *

(classNode: SyntaxNode, ctx: ExtractorContext)

 * naming. A member the source already declares is never overridden.
 */
function synthesizeLombokMembers(classNode: SyntaxNode, ctx: ExtractorContext): void {
  const classAnns = lombokAnnotationNames(classNode);
  const classGetter = classAnns.has('Getter');
  const classSetter = classAnns.has('Setter');
  const isData = classAnns.has('Data');
  const isValue = classAnns.has('Value');
  const hasBuilder = classAnns.has('Builder') || classAnns.has('SuperBuilder');
  const hasToString = isData || isValue || classAnns.has('ToString');
  const hasEquals = isData || isValue || classAnns.has('EqualsAndHashCode');
  const logAnn = [...classAnns].find((a) => LOMBOK_LOG_ANNOTATIONS.has(a));

  const body = getChildByField(classNode, 'body');
  if (!body) return;
  const fields = body.namedChildren.filter((c: SyntaxNode) => c.type === 'field_declaration');

  // Leave immediately when nothing Lombok is present, so a non-Lombok class
  // pays nothing beyond one scan of its direct field declarations (and an
  // annotated class skips even that — this hook runs for every Java class).
  const classHasLombok =
    classGetter || classSetter || isData || isValue || hasBuilder || hasToString || hasEquals || !!logAnn;
  if (!classHasLombok && !fields.some((f: SyntaxNode) => lombokAnnotationNames(f).size > 0)) {
    return;
  }

  // Members already declared directly in this class. Lombok never overrides an
  // explicit member, so we skip a name the source already has. Methods and
  // fields are tracked separately: they're distinct namespaces in Java (a
  // boolean field `isRunning` and its generated getter `isRunning()` coexist),
  // and the node id is keyed by kind so they never actually collide.
  const classId = ctx.nodeStack[ctx.nodeStack.length - 1];
  const classRec = ctx.nodes.find((n) => n.id === classId);
  const classQN = classRec?.qualifiedName;
  const takenMethods = new Set<string>();
  const takenFields = new Set<string>();
  if (classQN) {
    for (const n of ctx.nodes) {
      if (n.filePath === ctx.filePath && n.qualifiedName === `${classQN}::${n.name}`) {
        if (n.kind === 'method' || n.kind === 'function') takenMethods.add(n.name);
        else if (n.kind === 'field' || n.kind === 'variable' || n.kind === 'constant' || n.kind === 'property') {
          takenFields.add(n.name);
        }
      }
    }
  }

  const classNameNode = getChildByField(classNode, 'name') ?? classNode;
  const className = classRec?.name ?? getNodeText(classNameNode, ctx.source).trim();

  const emitMethod = (
    name: string,
    anchor: SyntaxNode,
    signature: string,
    fromAnnotation: string,
    extra: { returnType?: string; isStatic?: boolean } = {}
  ): void => {
    if (!name || takenMethods.has(name)) return;
    takenMethods.add(name);
    ctx.createNode('method', name, anchor, {