pi-hashline-edit-pro 7.0.0 → 7.1.0

package/src/outline/vendor/parsers/java.ts

@@ -25,113 +25,83 @@ export function extractJava(
     const child = node.namedChild(i);
     if (!child) continue;
 
-    const symbol = extractJavaTopLevel(child, source, depth, MAX_DEPTH);
+    const symbol = extractJavaType(child, source, depth, MAX_DEPTH);
     if (symbol) results.push(symbol);
   }
 
   return results;
 }
 
-function extractJavaType(
-  node: Node,
-  source: string,
-  depth: number,
-  MAX_DEPTH: number,
-): SymbolInfo | null {
-  switch (node.type) {
-    case "class_declaration":
-    case "interface_declaration":
-    case "enum_declaration":
-    case "record_declaration":
-    case "annotation_type_declaration":
-      return extractJavaTypeDeclaration(node, source, depth, MAX_DEPTH);
-    default:
-      return null;
+const JAVA_TYPE_LABELS: Record<string, string> = {
+  class_declaration: "class",
+  interface_declaration: "interface",
+  enum_declaration: "enum",
+  record_declaration: "record",
+  annotation_type_declaration: "annotation",
+};
+
+function fieldText(node: Node, field: string, source: string): string | undefined {
+  const child = node.childForFieldName(field);
+  return child === null ? undefined : source.slice(child.startIndex, child.endIndex);
+}
+
+function childText(node: Node, childType: string, source: string): string | undefined {
+  for (let index = 0; index < node.namedChildCount; index++) {
+    const child = node.namedChild(index);
+    if (child !== null && child.type === childType) return source.slice(child.startIndex, child.endIndex);
   }
+  return undefined;
 }
 
-function extractJavaTopLevel(
-  child: Node,
+const JAVA_SKIPPED_TYPES = new Set(["annotation", "marker_annotation", "comment", "line_comment", "block_comment"]);
+
+function firstDeclaredTokenRow(node: Node): number | undefined {
+  for (let index = 0; index < node.childCount; index++) {
+    const child = node.child(index);
+    if (child === null || JAVA_SKIPPED_TYPES.has(child.type)) continue;
+    if (child.type === "modifiers") {
+      for (let tokenIndex = 0; tokenIndex < child.childCount; tokenIndex++) {
+        const token = child.child(tokenIndex);
+        if (token === null || JAVA_SKIPPED_TYPES.has(token.type)) continue;
+        return token.startPosition.row + 1;
+      }
+      continue;
+    }
+    return child.startPosition.row + 1;
+  }
+  return undefined;
+}
+
+function declarationLine(node: Node): number {
+  return firstDeclaredTokenRow(node) ?? node.startPosition.row + 1;
+}
+
+function extractJavaType(
+  node: Node,
   source: string,
   depth: number,
   MAX_DEPTH: number,
 ): SymbolInfo | null {
-  return extractJavaType(child, source, depth, MAX_DEPTH);
+  if (JAVA_TYPE_LABELS[node.type] === undefined) return null;
+  return extractJavaTypeDeclaration(node, source, depth, MAX_DEPTH);
 }
 
 function extractJavaTypeDeclaration(
-  child: Node,
+  node: Node,
   source: string,
   depth: number,
   MAX_DEPTH: number,
-): SymbolInfo | null {
-  let typeName = "<unknown>";
-  let typeLabel = "class";
-  const modifiers: string[] = [];
-  let superClass: string | undefined;
-  const interfaces: string[] = [];
-  const extendsInterfaces: string[] = [];
-
-  if (child.type === "interface_declaration") typeLabel = "interface";
-  else if (child.type === "enum_declaration") typeLabel = "enum";
-  else if (child.type === "record_declaration") typeLabel = "record";
-  else if (child.type === "annotation_type_declaration") typeLabel = "annotation";
-
-  for (let j = 0; j < child.namedChildCount; j++) {
-    const c = child.namedChild(j);
-    if (!c) continue;
-
-    if (c.type === "modifiers") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "annotation") {
-          modifiers.push(source.slice(sub.startIndex, sub.endIndex));
-        }
-      }
-    } else if (c.type === "identifier") {
-      typeName = source.slice(c.startIndex, c.endIndex);
-    } else if (c.type === "superclass") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "extends") {
-          superClass = source.slice(sub.startIndex, sub.endIndex);
-        }
-      }
-    } else if (c.type === "super_interfaces") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "implements") {
-          interfaces.push(source.slice(sub.startIndex, sub.endIndex));
-        }
-      }
-    } else if (c.type === "extends_interfaces") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "extends") {
-          extendsInterfaces.push(source.slice(sub.startIndex, sub.endIndex));
-        }
-      }
-    }
-  }
-
-  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
-  const detailParts: string[] = [];
-  if (modifiers.length > 0) detailParts.push(modifiers.join(" "));
-  if (superClass) detailParts.push("extends " + superClass);
-  if (interfaces.length > 0) detailParts.push("implements " + interfaces.join(", "));
-  if (extendsInterfaces.length > 0) detailParts.push("extends " + extendsInterfaces.join(", "));
-
+): SymbolInfo {
   const symbol: SymbolInfo = {
-    name: typeName,
-    type: typeLabel,
-    startLine: sl,
-    endLine: el,
-    detail: detailParts.length > 0 ? detailParts.join(" ") : undefined,
+    name: fieldText(node, "name", source) ?? "<unknown>",
+    type: JAVA_TYPE_LABELS[node.type] ?? "class",
+    startLine: declarationLine(node),
+    endLine: node.endPosition.row + 1,
   };
 
   if (depth < MAX_DEPTH) {
-    const body = findClassBody(child);
-    if (body) {
+    const body = findClassBody(node);
+    if (body !== null) {
       const children = extractJavaClassBody(body, source, depth + 1, MAX_DEPTH);
       if (children.length > 0) symbol.children = children;
     }
@@ -142,15 +112,15 @@ function extractJavaTypeDeclaration(
 
 function findClassBody(node: Node): Node | null {
   for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (!c) continue;
+    const child = node.namedChild(i);
+    if (child === null) continue;
     if (
-      c.type === "class_body" ||
-      c.type === "enum_body" ||
-      c.type === "interface_body" ||
-      c.type === "annotation_type_body"
+      child.type === "class_body" ||
+      child.type === "enum_body" ||
+      child.type === "interface_body" ||
+      child.type === "annotation_type_body"
     ) {
-      return c;
+      return child;
     }
   }
   return null;
@@ -166,287 +136,132 @@ function extractJavaClassBody(
 
   for (let i = 0; i < body.namedChildCount; i++) {
     const child = body.namedChild(i);
-    if (!child) continue;
-
-    switch (child.type) {
-      case "method_declaration": {
-        const method = extractJavaMethod(child, source);
-        if (method) results.push(method);
-        break;
-      }
-      case "constructor_declaration": {
-        const ctor = extractJavaConstructor(child, source);
-        if (ctor) results.push(ctor);
-        break;
-      }
-      case "field_declaration": {
-        const fields = extractJavaFields(child, source);
-        results.push(...fields);
-        break;
-      }
-      case "class_declaration":
-      case "interface_declaration":
-      case "enum_declaration":
-      case "record_declaration":
-      case "annotation_type_declaration": {
-        const type = extractJavaTypeDeclaration(child, source, depth, MAX_DEPTH);
-        if (type) results.push(type);
-        break;
-      }
-      case "enum_constant": {
-        const ec = extractJavaEnumConstant(child, source);
-        if (ec) results.push(ec);
-        break;
-      }
-      case "static_initializer": {
-        const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
-        results.push({ name: "static", type: "static_initializer", startLine: sl, endLine: el });
-        break;
-      }
-    }
+    if (child === null) continue;
+    results.push(...extractJavaMember(child, source, depth, MAX_DEPTH));
   }
 
   return results;
 }
 
-function extractModifiers(node: Node, source: string): string[] {
-  const mods: string[] = [];
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (!c) continue;
-    if (c.type !== "annotation") {
-      mods.push(source.slice(c.startIndex, c.endIndex));
-    }
+function extractJavaMember(
+  node: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+): SymbolInfo[] {
+  switch (node.type) {
+    case "method_declaration":
+      return [extractJavaMethod(node, source)];
+    case "constructor_declaration":
+    case "compact_constructor_declaration":
+      return [extractJavaConstructor(node, source)];
+    case "field_declaration":
+    case "constant_declaration":
+      return extractJavaFields(node, source);
+    case "class_declaration":
+    case "interface_declaration":
+    case "enum_declaration":
+    case "record_declaration":
+    case "annotation_type_declaration":
+      return [extractJavaTypeDeclaration(node, source, depth, MAX_DEPTH)];
+    case "enum_constant":
+      return [extractJavaEnumConstant(node, source)];
+    case "annotation_type_element_declaration":
+      return [extractJavaAnnotationElement(node, source)];
+    case "enum_body_declarations":
+      return extractJavaClassBody(node, source, depth, MAX_DEPTH);
+    case "static_initializer":
+      return [{
+        name: "static",
+        type: "static_initializer",
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+      }];
+    default:
+      return [];
   }
-  return mods;
 }
 
 function extractJavaMethod(
-  child: Node,
+  node: Node,
   source: string,
-): SymbolInfo | null {
-  let methodName = "<unknown>";
-  const modifiers: string[] = [];
-  let returnType: string | undefined;
-  let params: string | undefined;
-  let typeParams: string | undefined;
-
-  for (let j = 0; j < child.namedChildCount; j++) {
-    const c = child.namedChild(j);
-    if (!c) continue;
-
-    if (c.type === "modifiers") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "annotation") {
-          modifiers.push(source.slice(sub.startIndex, sub.endIndex));
-        }
-      }
-    } else if (c.type === "_method_header") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (!sub) continue;
-
-        if (sub.type === "type_parameters") {
-          typeParams = source.slice(sub.startIndex, sub.endIndex);
-        } else if (sub.type === "_method_declarator") {
-          for (let m = 0; m < sub.namedChildCount; m++) {
-            const decl = sub.namedChild(m);
-            if (!decl) continue;
-            if (decl.type === "identifier") {
-              methodName = source.slice(decl.startIndex, decl.endIndex);
-            } else if (decl.type === "formal_parameters") {
-              params = source.slice(decl.startIndex, decl.endIndex);
-            }
-          }
-        } else if (sub.type !== "type_parameters" && sub.type !== "_method_declarator" && sub.type !== "throws") {
-          returnType = source.slice(sub.startIndex, sub.endIndex);
-        }
-      }
-    }
-  }
-
-  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
-  const detailParts: string[] = [];
-  if (modifiers.length > 0) detailParts.push(modifiers.join(" "));
-  if (typeParams) detailParts.push(typeParams);
-  if (returnType) detailParts.push(returnType);
-  if (params) detailParts.push(params);
-
+): SymbolInfo {
   return {
-    name: methodName,
+    name: fieldText(node, "name", source) ?? "<unknown>",
     type: "method",
-    startLine: sl,
-    endLine: el,
-    detail: detailParts.length > 0 ? detailParts.join(" ") : undefined,
+    startLine: declarationLine(node),
+    endLine: node.endPosition.row + 1,
   };
 }
 
 function extractJavaConstructor(
-  child: Node,
+  node: Node,
   source: string,
-): SymbolInfo | null {
-  let ctorName = "<unknown>";
-  const modifiers: string[] = [];
-  let params: string | undefined;
-  let typeParams: string | undefined;
-
-  for (let j = 0; j < child.namedChildCount; j++) {
-    const c = child.namedChild(j);
-    if (!c) continue;
-
-    if (c.type === "modifiers") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "annotation") {
-          modifiers.push(source.slice(sub.startIndex, sub.endIndex));
-        }
-      }
-    } else if (c.type === "_constructor_declarator") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (!sub) continue;
-        if (sub.type === "type_parameters") {
-          typeParams = source.slice(sub.startIndex, sub.endIndex);
-        } else if (sub.type === "identifier") {
-          ctorName = source.slice(sub.startIndex, sub.endIndex);
-        } else if (sub.type === "formal_parameters") {
-          params = source.slice(sub.startIndex, sub.endIndex);
-        }
-      }
-    }
-  }
-
-  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
-  const detailParts: string[] = [];
-  if (modifiers.length > 0) detailParts.push(modifiers.join(" "));
-  if (typeParams) detailParts.push(typeParams);
-  if (params) detailParts.push(params);
-
+): SymbolInfo {
   return {
-    name: ctorName,
+    name: fieldText(node, "name", source) ?? childText(node, "identifier", source) ?? "<unknown>",
     type: "constructor",
-    startLine: sl,
-    endLine: el,
-    detail: detailParts.length > 0 ? detailParts.join(" ") : undefined,
+    startLine: declarationLine(node),
+    endLine: node.endPosition.row + 1,
   };
 }
 
 function extractJavaFields(
-  child: Node,
+  node: Node,
   source: string,
 ): SymbolInfo[] {
   const results: SymbolInfo[] = [];
-  const modifiers: string[] = [];
-  let fieldType: string | undefined;
-
-  for (let j = 0; j < child.namedChildCount; j++) {
-    const c = child.namedChild(j);
-    if (!c) continue;
-
-    if (c.type === "modifiers") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const sub = c.namedChild(k);
-        if (sub && sub.type !== "annotation") {
-          modifiers.push(source.slice(sub.startIndex, sub.endIndex));
-        }
-      }
-    } else if (c.type === "_unannotated_type" || c.type === "type") {
-      fieldType = source.slice(c.startIndex, c.endIndex);
-    } else if (c.type === "_variable_declarator_list") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const decl = c.namedChild(k);
-        if (!decl) continue;
-        if (decl.type === "variable_declarator") {
-          const field = extractJavaVariableDeclarator(decl, source, modifiers, fieldType);
-          if (field) results.push(field);
-        }
-      }
-    }
+  const fieldStartLine = declarationLine(node);
+
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const declarator = node.namedChild(i);
+    if (declarator === null || declarator.type !== "variable_declarator") continue;
+
+    const declaratorStartLine = declarationLine(declarator);
+    results.push({
+      name: fieldText(declarator, "name", source) ?? "<unknown>",
+      type: "field",
+      startLine: results.length === 0 ? Math.min(fieldStartLine, declaratorStartLine) : declaratorStartLine,
+      endLine: declarator.endPosition.row + 1,
+    });
   }
 
   return results;
 }
 
-function extractJavaVariableDeclarator(
+function extractJavaEnumConstant(
   node: Node,
   source: string,
-  modifiers: string[],
-  fieldType: string | undefined,
-): SymbolInfo | null {
-  let fieldName = "<unknown>";
-  let fieldValue: string | undefined;
-
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (!c) continue;
-
-    if (c.type === "_variable_declarator_id") {
-      for (let j = 0; j < c.namedChildCount; j++) {
-        const sub = c.namedChild(j);
-        if (sub && sub.type === "identifier") {
-          fieldName = source.slice(sub.startIndex, sub.endIndex);
-        }
-      }
-    } else if (c.type === "=") {
-      for (let j = 0; j < c.namedChildCount; j++) {
-        const sub = c.namedChild(j);
-        if (sub) {
-          fieldValue = source.slice(sub.startIndex, sub.endIndex);
-        }
-      }
-    }
-  }
-
-  const [sl, el] = [node.startPosition.row + 1, node.endPosition.row + 1];
-  const detailParts: string[] = [];
-  if (modifiers.length > 0) detailParts.push(modifiers.join(" "));
-  if (fieldType) detailParts.push(fieldType);
-  if (fieldValue) detailParts.push("= " + fieldValue);
-
+): SymbolInfo {
   return {
-    name: fieldName,
-    type: "field",
-    startLine: sl,
-    endLine: el,
-    detail: detailParts.length > 0 ? detailParts.join(" ") : undefined,
+    name: fieldText(node, "name", source) ?? "<unknown>",
+    type: "enum_constant",
+    startLine: declarationLine(node),
+    endLine: node.endPosition.row + 1,
   };
 }
 
-function extractJavaEnumConstant(
-  child: Node,
+function extractJavaAnnotationElement(
+  node: Node,
   source: string,
-): SymbolInfo | null {
-  let constName = "<unknown>";
-  let constArgs: string | undefined;
-
-  for (let j = 0; j < child.namedChildCount; j++) {
-    const c = child.namedChild(j);
-    if (!c) continue;
-
-    if (c.type === "identifier") {
-      constName = source.slice(c.startIndex, c.endIndex);
-    } else if (c.type === "argument_list") {
-      constArgs = source.slice(c.startIndex, c.endIndex);
-    }
-  }
-
-  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
-  const detailParts: string[] = [];
-  if (constArgs) detailParts.push(constArgs);
-
+): SymbolInfo {
   return {
-    name: constName,
-    type: "enum_constant",
-    startLine: sl,
-    endLine: el,
-    detail: detailParts.length > 0 ? detailParts.join(" ") : undefined,
+    name: fieldText(node, "name", source) ?? "<unknown>",
+    type: "element",
+    startLine: declarationLine(node),
+    endLine: node.endPosition.row + 1,
   };
 }
 
+function importIsStatic(declaration: string): boolean {
+  const withoutComments = declaration.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
+  return /^\s*import\s+static\b/.test(withoutComments);
+}
+
 /**
  * Extract Java imports.
  */
+
 export function extractJavaImports(
   node: Node,
   source: string,
@@ -459,16 +274,14 @@ export function extractJavaImports(
 
     if (child.type === "import_declaration") {
       let importSource = "";
-      let isStatic = false;
+      const isStatic = importIsStatic(source.slice(child.startIndex, child.endIndex));
       let isWildcard = false;
 
       for (let j = 0; j < child.namedChildCount; j++) {
         const c = child.namedChild(j);
         if (!c) continue;
 
-        if (c.type === "static" || source.slice(c.startIndex, c.endIndex) === "static") {
-          isStatic = true;
-        } else if (c.type === "asterisk") {
+        if (c.type === "asterisk") {
           isWildcard = true;
         } else if (c.type === "scoped_identifier" || c.type === "identifier") {
           importSource = source.slice(c.startIndex, c.endIndex);