android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/jvm/protocol.js

@@ -0,0 +1,408 @@
+import { readFileSync } from "node:fs";
+import { hardFailure } from "../diagnostics.js";
+export const JVM_RAW_PROTOCOL = "mobile-app-reqgen.raw-jvm";
+export const JVM_RAW_SCHEMA_VERSION = "1.0.0";
+export const jvmKnownEventKinds = [
+  "analysis-header",
+  "source-file",
+  "class-declaration",
+  "method-declaration",
+  "lambda-declaration",
+  "callable-reference",
+  "resolved-call",
+  "unresolved-call",
+  "call-argument-binding",
+  "assignment",
+  "return",
+  "condition",
+  "xml-element",
+  "xml-attribute",
+  "analysis-footer",
+];
+export const jvmProtocolErrorCodes = {
+  empty: "JVM_PROTOCOL_EMPTY",
+  blankLine: "JVM_PROTOCOL_BLANK_LINE",
+  invalidJson: "JVM_PROTOCOL_JSON_INVALID",
+  invalidRecord: "JVM_PROTOCOL_RECORD_INVALID",
+  unsupportedProtocol: "JVM_PROTOCOL_NAME_UNSUPPORTED",
+  unsupportedVersion: "JVM_PROTOCOL_VERSION_UNSUPPORTED",
+  headerRequired: "JVM_PROTOCOL_HEADER_REQUIRED",
+  footerRequired: "JVM_PROTOCOL_FOOTER_REQUIRED",
+  controlOrder: "JVM_PROTOCOL_CONTROL_ORDER_INVALID",
+  invalidHeader: "JVM_PROTOCOL_HEADER_INVALID",
+  invalidFooter: "JVM_PROTOCOL_FOOTER_INVALID",
+  duplicateId: "JVM_PROTOCOL_DUPLICATE_ID",
+  eventCountMismatch: "JVM_PROTOCOL_EVENT_COUNT_MISMATCH",
+  readFailed: "JVM_OUTPUT_READ_FAILED",
+};
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function recordFailure(code, message, line, details) {
+  throw hardFailure(code, "uast", message, undefined, {
+    ...(line === undefined ? {} : { line }),
+    ...details,
+  });
+}
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+const envelopeKeys = new Set([
+  "protocol",
+  "schemaVersion",
+  "kind",
+  "id",
+  "location",
+  "data",
+]);
+const locationKeys = new Set([
+  "path",
+  "startLine",
+  "startColumn",
+  "endLine",
+  "endColumn",
+  "startOffset",
+  "endOffset",
+]);
+function isSourceCoordinate(value) {
+  return (
+    Number.isInteger(value) &&
+    typeof value === "number" &&
+    (value === -1 || value >= 1)
+  );
+}
+function isOffset(value) {
+  return Number.isInteger(value) && typeof value === "number" && value >= -1;
+}
+function parseLocation(value, line) {
+  if (
+    !isRecord(value) ||
+    !hasOnlyKeys(value, locationKeys) ||
+    typeof value.path !== "string" ||
+    value.path.length === 0 ||
+    value.path.startsWith("/") ||
+    /^[A-Za-z]:/u.test(value.path) ||
+    value.path.includes("\\") ||
+    !isSourceCoordinate(value.startLine) ||
+    !isSourceCoordinate(value.startColumn) ||
+    !isSourceCoordinate(value.endLine) ||
+    !isSourceCoordinate(value.endColumn) ||
+    !isOffset(value.startOffset) ||
+    !isOffset(value.endOffset)
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidRecord,
+      `Raw JVM record on line ${line} has an invalid location.`,
+      line,
+    );
+  }
+  if (
+    value.startLine !== -1 &&
+    value.endLine !== -1 &&
+    value.endLine < value.startLine
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidRecord,
+      `Raw JVM record on line ${line} has a reversed line range.`,
+      line,
+    );
+  }
+  if (
+    value.startOffset !== -1 &&
+    value.endOffset !== -1 &&
+    value.endOffset < value.startOffset
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidRecord,
+      `Raw JVM record on line ${line} has a reversed offset range.`,
+      line,
+    );
+  }
+  return {
+    path: value.path,
+    startLine: value.startLine,
+    startColumn: value.startColumn,
+    endLine: value.endLine,
+    endColumn: value.endColumn,
+    startOffset: value.startOffset,
+    endOffset: value.endOffset,
+  };
+}
+function parseRecord(value, line) {
+  if (!isRecord(value)) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidRecord,
+      `Raw JVM line ${line} must contain a JSON object.`,
+      line,
+    );
+  }
+  if (value.protocol !== JVM_RAW_PROTOCOL) {
+    return recordFailure(
+      jvmProtocolErrorCodes.unsupportedProtocol,
+      `Raw JVM line ${line} uses an unsupported protocol.`,
+      line,
+      {
+        expected: JVM_RAW_PROTOCOL,
+        actual: value.protocol,
+      },
+    );
+  }
+  if (value.schemaVersion !== JVM_RAW_SCHEMA_VERSION) {
+    return recordFailure(
+      jvmProtocolErrorCodes.unsupportedVersion,
+      `Raw JVM line ${line} uses an unsupported schema version.`,
+      line,
+      {
+        expected: JVM_RAW_SCHEMA_VERSION,
+        actual: value.schemaVersion,
+      },
+    );
+  }
+  if (
+    !hasOnlyKeys(value, envelopeKeys) ||
+    typeof value.kind !== "string" ||
+    value.kind.trim().length === 0 ||
+    typeof value.id !== "string" ||
+    value.id.trim().length === 0 ||
+    !isRecord(value.data)
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidRecord,
+      `Raw JVM record on line ${line} has an invalid v1 envelope.`,
+      line,
+    );
+  }
+  return {
+    protocol: JVM_RAW_PROTOCOL,
+    schemaVersion: JVM_RAW_SCHEMA_VERSION,
+    kind: value.kind,
+    id: value.id,
+    ...("location" in value
+      ? { location: parseLocation(value.location, line) }
+      : {}),
+    data: value.data,
+  };
+}
+function parseHeader(record) {
+  const data = record.data;
+  if (
+    data.engine !== "android-lint-uast" ||
+    typeof data.engineVersion !== "string" ||
+    data.engineVersion.trim().length === 0 ||
+    data.protocolVersion !== JVM_RAW_SCHEMA_VERSION ||
+    typeof data.project !== "string" ||
+    data.project.trim().length === 0
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidHeader,
+      "Raw JVM analysis header is invalid.",
+      1,
+    );
+  }
+  return {
+    ...record,
+    kind: "analysis-header",
+    data: {
+      ...data,
+      engine: "android-lint-uast",
+      engineVersion: data.engineVersion,
+      protocolVersion: JVM_RAW_SCHEMA_VERSION,
+      project: data.project,
+    },
+  };
+}
+function parseCounts(value, line) {
+  if (!isRecord(value)) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidFooter,
+      "Raw JVM analysis footer has invalid countsByKind.",
+      line,
+    );
+  }
+  const counts = {};
+  for (const [kind, count] of Object.entries(value)) {
+    if (
+      kind.trim().length === 0 ||
+      typeof count !== "number" ||
+      !Number.isInteger(count) ||
+      count < 0
+    ) {
+      return recordFailure(
+        jvmProtocolErrorCodes.invalidFooter,
+        "Raw JVM analysis footer has invalid countsByKind.",
+        line,
+      );
+    }
+    counts[kind] = count;
+  }
+  return counts;
+}
+function parseFooter(record, line) {
+  const data = record.data;
+  if (
+    data.complete !== true ||
+    typeof data.recordCount !== "number" ||
+    !Number.isInteger(data.recordCount) ||
+    data.recordCount < 0
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.invalidFooter,
+      "Raw JVM analysis footer is invalid.",
+      line,
+    );
+  }
+  const countsByKind = parseCounts(data.countsByKind, line);
+  return {
+    ...record,
+    kind: "analysis-footer",
+    data: {
+      ...data,
+      complete: true,
+      recordCount: data.recordCount,
+      countsByKind,
+    },
+  };
+}
+function countKinds(records) {
+  const counts = {};
+  for (const record of records) {
+    counts[record.kind] = (counts[record.kind] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(counts).sort(([left], [right]) =>
+      left.localeCompare(right, "en"),
+    ),
+  );
+}
+function sameCounts(actual, declared) {
+  const actualKinds = Object.keys(actual).sort();
+  const declaredKinds = Object.keys(declared).sort();
+  return (
+    actualKinds.length === declaredKinds.length &&
+    actualKinds.every(
+      (kind, index) =>
+        kind === declaredKinds[index] && actual[kind] === declared[kind],
+    )
+  );
+}
+export function parseJvmNdjson(input) {
+  const lines = input.split(/\r?\n/u);
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+    return recordFailure(
+      jvmProtocolErrorCodes.empty,
+      "Raw JVM output is empty.",
+    );
+  }
+  const records = lines.map((line, index) => {
+    const lineNumber = index + 1;
+    if (line.trim().length === 0) {
+      return recordFailure(
+        jvmProtocolErrorCodes.blankLine,
+        `Raw JVM output contains a blank line at ${lineNumber}.`,
+        lineNumber,
+      );
+    }
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch (error) {
+      return recordFailure(
+        jvmProtocolErrorCodes.invalidJson,
+        `Raw JVM line ${lineNumber} is not valid JSON.`,
+        lineNumber,
+        {
+          cause: error instanceof Error ? error.message : String(error),
+        },
+      );
+    }
+    return parseRecord(value, lineNumber);
+  });
+  if (records[0]?.kind !== "analysis-header") {
+    return recordFailure(
+      jvmProtocolErrorCodes.headerRequired,
+      "Raw JVM output must start with analysis-header.",
+      1,
+    );
+  }
+  const lastIndex = records.length - 1;
+  if (records[lastIndex]?.kind !== "analysis-footer") {
+    return recordFailure(
+      jvmProtocolErrorCodes.footerRequired,
+      "Raw JVM output must end with analysis-footer.",
+      records.length,
+    );
+  }
+  const body = records.slice(1, -1);
+  const nestedControlIndex = body.findIndex(
+    (record) =>
+      record.kind === "analysis-header" || record.kind === "analysis-footer",
+  );
+  if (nestedControlIndex !== -1) {
+    const line = nestedControlIndex + 2;
+    return recordFailure(
+      jvmProtocolErrorCodes.controlOrder,
+      `Raw JVM control record is out of order on line ${line}.`,
+      line,
+    );
+  }
+  const seenIds = new Set();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (seenIds.has(record.id)) {
+      const line = index + 1;
+      return recordFailure(
+        jvmProtocolErrorCodes.duplicateId,
+        `Raw JVM record ID is duplicated on line ${line}.`,
+        line,
+        { id: record.id },
+      );
+    }
+    seenIds.add(record.id);
+  }
+  const header = parseHeader(records[0]);
+  const footer = parseFooter(records[lastIndex], records.length);
+  const countsByKind = countKinds(body);
+  if (
+    footer.data.recordCount !== body.length ||
+    !sameCounts(countsByKind, footer.data.countsByKind)
+  ) {
+    return recordFailure(
+      jvmProtocolErrorCodes.eventCountMismatch,
+      "Raw JVM footer event counts do not match the body.",
+      records.length,
+      {
+        actualRecordCount: body.length,
+        declaredRecordCount: footer.data.recordCount,
+        actualCountsByKind: countsByKind,
+        declaredCountsByKind: footer.data.countsByKind,
+      },
+    );
+  }
+  return {
+    header,
+    body,
+    footer,
+    records,
+    countsByKind,
+  };
+}
+export function readJvmNdjsonFile(path) {
+  let input;
+  try {
+    input = readFileSync(path, "utf8");
+  } catch (error) {
+    throw hardFailure(
+      jvmProtocolErrorCodes.readFailed,
+      "uast",
+      `Unable to read raw JVM output: ${path}`,
+      undefined,
+      {
+        cause: error instanceof Error ? error.message : String(error),
+      },
+    );
+  }
+  return parseJvmNdjson(input);
+}