android2harmony 0.1.7 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/area-titles.js

@@ -0,0 +1,678 @@
+import {
+  camelToSnakeResourceId,
+  resourceIdsEquivalent,
+} from "./resource-id.js";
+const areaComponentTypes = new Set([
+  "activity",
+  "fragment",
+  "composable",
+  "compose-destination",
+  "dialog",
+  "drawer",
+  "bottom-sheet",
+  "overlay",
+  "pager",
+  "pager-page",
+  "inline-detail-surface",
+  "popup",
+  "widget",
+]);
+const identifierNoiseTokens = new Set([
+  "label",
+  "text",
+  "textview",
+  "tv",
+  "view",
+]);
+function objectValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+}
+function objectText(value, key) {
+  const item = value?.[key];
+  return typeof item === "string" && item.trim().length > 0
+    ? item.trim()
+    : undefined;
+}
+function recordText(record, key) {
+  return objectText(record.data, key);
+}
+function recordNumber(record, key) {
+  const value = record.data[key];
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}
+function nonBlank(value) {
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+function simpleName(value) {
+  const dot = value.lastIndexOf(".");
+  const dollar = value.lastIndexOf("$");
+  return value.slice(Math.max(dot, dollar) + 1);
+}
+function isTextViewName(value) {
+  return simpleName(value).toLowerCase().endsWith("textview");
+}
+function isTextView(view) {
+  return isTextViewName(view.tag);
+}
+function identifierTokens(value) {
+  const tokens = value
+    .replace(/([a-z0-9])([A-Z])/gu, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/gu, "$1_$2")
+    .split(/[^A-Za-z0-9]+/u)
+    .map((token) => token.toLowerCase())
+    .filter((token) => token.length > 0);
+  while (tokens.length > 0 && identifierNoiseTokens.has(tokens[0])) {
+    tokens.shift();
+  }
+  while (
+    tokens.length > 0 &&
+    identifierNoiseTokens.has(tokens[tokens.length - 1])
+  ) {
+    tokens.pop();
+  }
+  return tokens;
+}
+/**
+ * Title evidence must come from an identifier whose semantic tail is exactly
+ * "title" or "header". This accepts generic forms such as toolbar_title,
+ * screenTitle and tv_home_title, while rejecting subtitle, title_icon and
+ * status_text.
+ */
+function isTitleResourceId(resourceId) {
+  const tokens = identifierTokens(resourceId);
+  const tail = tokens[tokens.length - 1];
+  return tail === "title" || tail === "header";
+}
+/**
+ * Android and Material expose semantic title/headline text appearances. A
+ * selected static TextView using one of those styles is stronger title
+ * evidence than its position in the XML tree, even when it has no id.
+ */
+function hasTitleTextAppearance(view) {
+  const values = [
+    view.textAppearance?.raw,
+    view.textAppearance?.resolved,
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  return values.some((value) =>
+    /(?:textappearance(?:large|headline|title)|(?:^|[._/:])(?:display|headline|title)(?:[._/:]|$))/iu.test(
+      value,
+    ),
+  );
+}
+function sourceKind(record) {
+  const language = recordText(record, "language");
+  if (language === "kotlin" || record.location?.path.endsWith(".kt")) {
+    return "kotlin";
+  }
+  if (language === "java" || record.location?.path.endsWith(".java")) {
+    return "java";
+  }
+  return "other";
+}
+function recordLocation(record, anchor) {
+  if (!record.location) return undefined;
+  return {
+    sourceKind: sourceKind(record),
+    path: record.location.path,
+    anchor,
+    range: {
+      startLine: Math.max(1, record.location.startLine),
+      endLine: Math.max(
+        Math.max(1, record.location.startLine),
+        record.location.endLine,
+      ),
+      ...(record.location.startColumn >= 1
+        ? { startColumn: record.location.startColumn }
+        : {}),
+      ...(record.location.endColumn >= 1
+        ? { endColumn: record.location.endColumn }
+        : {}),
+    },
+    ...(recordText(record, "enclosingMethod")
+      ? { symbol: recordText(record, "enclosingMethod") }
+      : {}),
+  };
+}
+function supportKey(support) {
+  const location = support.location;
+  return [
+    support.role,
+    location.sourceKind,
+    location.path,
+    location.anchor,
+    location.symbol ?? "",
+    location.range.startLine,
+    location.range.endLine,
+  ].join("\u0000");
+}
+function uniqueSupport(support) {
+  const byKey = new Map();
+  support.forEach((item) => byKey.set(supportKey(item), item));
+  return [...byKey.values()].sort((left, right) =>
+    supportKey(left).localeCompare(supportKey(right), "en"),
+  );
+}
+function uniqueStrings(values) {
+  return [
+    ...new Set(
+      values.map((value) => value.trim()).filter((value) => value.length > 0),
+    ),
+  ].sort((left, right) => left.localeCompare(right, "en"));
+}
+function localStringReference(raw, applicationId) {
+  const match =
+    /^@(?:\+)?(?:(?<package>[^:/]+):)?string\/(?<name>[^/]+)$/u.exec(
+      raw.trim(),
+    );
+  const packageName = match?.groups?.package;
+  if (
+    packageName === "android" ||
+    (packageName !== undefined && packageName !== applicationId)
+  )
+    return undefined;
+  return match?.groups?.name;
+}
+function selectedStringRecords(android, name) {
+  return android.values.filter(
+    (record) => record.resourceType === "string" && record.name === name,
+  );
+}
+function resolveSelectedString(android, name, seen = new Set()) {
+  if (seen.has(name)) return undefined;
+  const records = selectedStringRecords(android, name);
+  if (records.length === 0) return undefined;
+  const nextSeen = new Set([...seen, name]);
+  const resolutions = records.flatMap((record) => {
+    const raw = nonBlank(record.value);
+    if (!raw) return [];
+    const alias = localStringReference(raw, android.manifest.packageName);
+    const nested = alias
+      ? resolveSelectedString(android, alias, nextSeen)
+      : undefined;
+    if (raw.startsWith("@") && !nested) return [];
+    return [
+      {
+        value: nested?.value ?? raw,
+        support: [
+          {
+            location: record.evidence,
+            role: "selected string resource for Area title",
+          },
+          ...(nested?.support ?? []),
+        ],
+        resourceNames: [name, ...(nested?.resourceNames ?? [])],
+      },
+    ];
+  });
+  const values = uniqueStrings(resolutions.map((item) => item.value));
+  if (values.length !== 1) return undefined;
+  const matching = resolutions.filter((item) => item.value === values[0]);
+  return {
+    value: values[0],
+    support: uniqueSupport(matching.flatMap((item) => item.support)),
+    resourceNames: uniqueStrings(
+      matching.flatMap((item) => item.resourceNames),
+    ),
+  };
+}
+function resourceFactRefs(state, resourceNames) {
+  const names = new Set(resourceNames);
+  return state.builder
+    .facts("resource-value")
+    .flatMap((fact) =>
+      fact.kind === "resource-value" &&
+      fact.data.resourceType === "string" &&
+      names.has(fact.data.resourceName)
+        ? [fact.id]
+        : [],
+    );
+}
+function ownerIsArea(state, ownerRef) {
+  const owner = state.builder.fact(ownerRef);
+  return (
+    owner?.kind === "component" &&
+    areaComponentTypes.has(owner.data.componentType) &&
+    !owner.data.qualifiedName.startsWith("@layout/")
+  );
+}
+function ownerUiTextViews(state, ownerRef, resourceId) {
+  return [...(state.uiByResourceId.get(resourceId) ?? [])]
+    .filter((factRef) => {
+      const fact = state.builder.fact(factRef);
+      return (
+        fact?.kind === "ui-element" &&
+        fact.data.ownerKey === ownerRef &&
+        fact.data.resourceId !== undefined &&
+        resourceIdsEquivalent(fact.data.resourceId, resourceId) &&
+        isTextViewName(fact.data.elementType)
+      );
+    })
+    .sort((left, right) => left.localeCompare(right, "en"));
+}
+function xmlStaticString(android, view) {
+  const resolved = nonBlank(view.text?.resolved);
+  const raw = nonBlank(view.text?.raw);
+  const resourceName = raw
+    ? localStringReference(raw, android.manifest.packageName)
+    : undefined;
+  const selected = resourceName
+    ? resolveSelectedString(android, resourceName)
+    : undefined;
+  if (resolved) {
+    return {
+      value: resolved,
+      support: selected?.value === resolved ? selected.support : [],
+      resourceNames: selected?.value === resolved ? selected.resourceNames : [],
+    };
+  }
+  if (!raw) return undefined;
+  if (!raw.startsWith("@")) {
+    return { value: raw, support: [], resourceNames: [] };
+  }
+  return selected;
+}
+function xmlTitleCandidates(android, state) {
+  const candidates = [];
+  for (const view of android.views) {
+    if (
+      view.resourceType !== "layout" ||
+      !(
+        (view.id && isTitleResourceId(view.id)) ||
+        hasTitleTextAppearance(view)
+      ) ||
+      !isTextView(view)
+    )
+      continue;
+    const title = xmlStaticString(android, view);
+    if (!title) continue;
+    const owners = [
+      ...(state.layoutOwners.get(view.resourceName) ?? []),
+    ].sort();
+    for (const ownerRef of owners) {
+      if (!ownerIsArea(state, ownerRef)) continue;
+      candidates.push({
+        ownerRef,
+        value: title.value,
+        support: uniqueSupport([
+          {
+            location: view.evidence,
+            role: "selected XML title TextView",
+          },
+          ...title.support,
+        ]),
+        relatedFactRefs: uniqueStrings([
+          ownerRef,
+          ...(view.id ? ownerUiTextViews(state, ownerRef, view.id) : []),
+          ...resourceFactRefs(state, title.resourceNames),
+        ]),
+      });
+    }
+  }
+  return candidates;
+}
+function navigationLabelCandidates(android, state) {
+  return android.fragments.flatMap((fragment) => {
+    const label = fragment.label;
+    if (!label) return [];
+    const value =
+      nonBlank(label.resolved) ??
+      (!label.raw.startsWith("@") ? nonBlank(label.raw) : undefined);
+    if (!value) return [];
+    const className =
+      fragment.className.startsWith(".") && android.manifest.packageName
+        ? `${android.manifest.packageName}${fragment.className}`
+        : fragment.className.includes(".") || !android.manifest.packageName
+          ? fragment.className
+          : `${android.manifest.packageName}.${fragment.className}`;
+    const ownerRef = state.componentByQualifiedName.get(className);
+    if (!ownerRef || !ownerIsArea(state, ownerRef)) return [];
+    const resourceName = localStringReference(
+      label.raw,
+      android.manifest.packageName,
+    );
+    return [
+      {
+        ownerRef,
+        value,
+        support: [
+          {
+            location: fragment.evidence,
+            role: "selected navigation destination label",
+          },
+        ],
+        relatedFactRefs: uniqueStrings([
+          ownerRef,
+          ...(resourceName ? resourceFactRefs(state, [resourceName]) : []),
+        ]),
+      },
+    ];
+  });
+}
+function isBindingClass(value) {
+  if (!value) return false;
+  const name = simpleName(value);
+  return /^[A-Z][A-Za-z0-9]*Binding$/u.test(name) && name !== "ViewDataBinding";
+}
+function bindingPropertyResourceIdFromSymbol(symbol) {
+  if (!isBindingClass(objectText(symbol, "ownerQualifiedName")))
+    return undefined;
+  const rawName = objectText(symbol, "name");
+  if (!rawName) return undefined;
+  const propertyName = /^get[A-Z]/u.test(rawName)
+    ? `${rawName[3]?.toLowerCase() ?? ""}${rawName.slice(4)}`
+    : rawName;
+  if (propertyName === "root") return undefined;
+  return camelToSnakeResourceId(propertyName);
+}
+function bindingPropertyResourceId(expression) {
+  return bindingPropertyResourceIdFromSymbol(
+    objectValue(expression.resolvedSymbol),
+  );
+}
+function expressionOf(binding) {
+  return objectValue(binding.data.expression);
+}
+function isResolvedBinding(binding) {
+  return recordText(binding, "bindingStatus") === "resolved";
+}
+function resourceReferenceOf(expression) {
+  return objectValue(expression.resourceReference);
+}
+function isFrameworkFindViewById(call) {
+  if (recordText(call, "targetName") !== "findViewById") return false;
+  const owner = recordText(call, "targetOwnerQualifiedName") ?? "";
+  return /^(?:android\.(?:app\.(?:Activity|Dialog)|view\.(?:View|Window))|androidx\.appcompat\.app\.AppCompat(?:Activity|Dialog))$/u.test(
+    owner,
+  );
+}
+function structuredResourceId(expression, index) {
+  const resource = resourceReferenceOf(expression);
+  if (objectText(resource, "resourceType") === "id") {
+    return objectText(resource, "resourceName");
+  }
+  const property = bindingPropertyResourceId(expression);
+  if (property) return property;
+  const callRef = objectText(expression, "callRef");
+  if (!callRef) return undefined;
+  const call = index.resolvedCallsById.get(callRef);
+  if (!call || !isFrameworkFindViewById(call)) return undefined;
+  const ids = uniqueStrings(
+    (index.bindingsByCallRef.get(callRef) ?? [])
+      .filter(
+        (binding) =>
+          isResolvedBinding(binding) &&
+          recordNumber(binding, "argumentIndex") === 0,
+      )
+      .flatMap((binding) => {
+        const nested = expressionOf(binding);
+        if (!nested) return [];
+        const nestedResource = resourceReferenceOf(nested);
+        return objectText(nestedResource, "resourceType") === "id"
+          ? [objectText(nestedResource, "resourceName") ?? ""]
+          : [];
+      }),
+  );
+  return ids.length === 1 ? ids[0] : undefined;
+}
+function receiverResourceId(call, index) {
+  const receiver = objectValue(call.data.receiverResolvedSymbol);
+  const receiverExpression = objectValue(call.data.receiverExpression);
+  const candidates = uniqueStrings([
+    receiver ? (bindingPropertyResourceIdFromSymbol(receiver) ?? "") : "",
+    receiverExpression
+      ? (structuredResourceId(receiverExpression, index) ?? "")
+      : "",
+    ...(receiver && objectValue(receiver.initializer)
+      ? [structuredResourceId(objectValue(receiver.initializer), index) ?? ""]
+      : []),
+  ]);
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function hasBranchContext(record) {
+  const refs = record.data.conditionRefs;
+  const contexts = record.data.conditionContexts;
+  return (
+    (Array.isArray(refs) && refs.length > 0) ||
+    (Array.isArray(contexts) && contexts.length > 0)
+  );
+}
+function isStaticStringAccessor(call) {
+  const name = recordText(call, "targetName");
+  if (name !== "getString" && name !== "getText") return false;
+  const owner = recordText(call, "targetOwnerQualifiedName") ?? "";
+  return /^(?:android\.(?:app\.(?:Activity|Fragment)|content\.(?:Context|ContextWrapper)|content\.res\.Resources)|androidx\.fragment\.app\.Fragment)$/u.test(
+    owner,
+  );
+}
+function resolveStaticExpression(expression, android, index, seen = new Set()) {
+  const constant = nonBlank(expression.constantValue);
+  if (constant) {
+    return { value: constant, support: [], resourceNames: [] };
+  }
+  const resource = resourceReferenceOf(expression);
+  if (objectText(resource, "resourceType") === "string") {
+    if (objectText(resource, "rClassQualifiedName") === "android.R") {
+      return undefined;
+    }
+    const resourceName = objectText(resource, "resourceName");
+    return resourceName
+      ? resolveSelectedString(android, resourceName)
+      : undefined;
+  }
+  const callRef = objectText(expression, "callRef");
+  if (!callRef || seen.has(callRef)) return undefined;
+  const call = index.resolvedCallsById.get(callRef);
+  if (!call || !isStaticStringAccessor(call) || hasBranchContext(call)) {
+    return undefined;
+  }
+  const bindings = (index.bindingsByCallRef.get(callRef) ?? []).filter(
+    (binding) =>
+      isResolvedBinding(binding) &&
+      recordNumber(binding, "argumentIndex") !== undefined,
+  );
+  if (bindings.length !== 1 || recordNumber(bindings[0], "argumentIndex") !== 0)
+    return undefined;
+  const nestedExpression = expressionOf(bindings[0]);
+  if (!nestedExpression) return undefined;
+  const nested = resolveStaticExpression(
+    nestedExpression,
+    android,
+    index,
+    new Set([...seen, callRef]),
+  );
+  if (!nested) return undefined;
+  const callLocation = recordLocation(
+    call,
+    `area-title:string-accessor:${
+      recordText(call, "targetSignature") ??
+      recordText(call, "targetName") ??
+      call.id
+    }`,
+  );
+  const bindingLocation = recordLocation(
+    bindings[0],
+    `area-title:string-argument:${call.id}`,
+  );
+  return {
+    ...nested,
+    support: uniqueSupport([
+      ...nested.support,
+      ...(callLocation
+        ? [
+            {
+              location: callLocation,
+              role: "structured static string accessor",
+            },
+          ]
+        : []),
+      ...(bindingLocation
+        ? [
+            {
+              location: bindingLocation,
+              role: "structured static string argument",
+            },
+          ]
+        : []),
+    ]),
+  };
+}
+function setTextStaticString(call, android, index) {
+  const resolutions = (index.bindingsByCallRef.get(call.id) ?? [])
+    .filter(
+      (binding) =>
+        isResolvedBinding(binding) &&
+        recordNumber(binding, "argumentIndex") === 0,
+    )
+    .flatMap((binding) => {
+      const expression = expressionOf(binding);
+      const resolved = expression
+        ? resolveStaticExpression(expression, android, index)
+        : undefined;
+      if (!resolved) return [];
+      const location = recordLocation(
+        binding,
+        `area-title:setText-argument:${call.id}`,
+      );
+      return [
+        {
+          ...resolved,
+          support: uniqueSupport([
+            ...resolved.support,
+            ...(location
+              ? [
+                  {
+                    location,
+                    role: "structured static TextView.setText argument",
+                  },
+                ]
+              : []),
+          ]),
+        },
+      ];
+    });
+  const values = uniqueStrings(resolutions.map((item) => item.value));
+  if (values.length !== 1) return undefined;
+  const matching = resolutions.filter((item) => item.value === values[0]);
+  return {
+    value: values[0],
+    support: uniqueSupport(matching.flatMap((item) => item.support)),
+    resourceNames: uniqueStrings(
+      matching.flatMap((item) => item.resourceNames),
+    ),
+  };
+}
+function isTextViewSetText(call) {
+  if (recordText(call, "targetName") !== "setText") return false;
+  return [
+    recordText(call, "targetOwnerQualifiedName"),
+    recordText(call, "receiverType"),
+  ].some((type) => type !== undefined && isTextViewName(type));
+}
+function jvmTitleCandidates(android, state, index) {
+  const candidates = [];
+  for (const call of index.resolvedCallsById.values()) {
+    if (!isTextViewSetText(call) || hasBranchContext(call)) continue;
+    const enclosingClass = recordText(call, "enclosingClass");
+    const ownerRef = enclosingClass
+      ? state.componentByQualifiedName.get(enclosingClass)
+      : undefined;
+    if (!ownerRef || !ownerIsArea(state, ownerRef)) continue;
+    const resourceId = receiverResourceId(call, index);
+    if (!resourceId || !isTitleResourceId(resourceId)) continue;
+    const uiFacts = ownerUiTextViews(state, ownerRef, resourceId);
+    if (uiFacts.length !== 1) continue;
+    const title = setTextStaticString(call, android, index);
+    const location = recordLocation(
+      call,
+      `area-title:setText:${
+        recordText(call, "targetSignature") ??
+        recordText(call, "source") ??
+        call.id
+      }`,
+    );
+    if (!title || !location) continue;
+    candidates.push({
+      ownerRef,
+      value: title.value,
+      support: uniqueSupport([
+        {
+          location,
+          role: "structured TextView.setText Area title",
+        },
+        ...title.support,
+      ]),
+      relatedFactRefs: uniqueStrings([
+        ownerRef,
+        uiFacts[0],
+        ...resourceFactRefs(state, title.resourceNames),
+      ]),
+    });
+  }
+  return candidates;
+}
+function ownersWithExistingTitle(state) {
+  return new Set(
+    state.builder
+      .facts("ui-property")
+      .flatMap((fact) =>
+        fact.kind === "ui-property" && fact.data.property === "title"
+          ? [fact.data.ownerKey]
+          : [],
+      ),
+  );
+}
+/**
+ * Adds a title only when all conservative, owner-specific candidates agree.
+ * Repeated corroborating evidence for the same static value is safe; two
+ * distinct values are ambiguous and intentionally produce no title fact.
+ */
+export function normalizeAreaTitleFacts(android, state, index) {
+  const candidates = [
+    ...navigationLabelCandidates(android, state),
+    ...xmlTitleCandidates(android, state),
+    ...jvmTitleCandidates(android, state, index),
+  ];
+  const existing = ownersWithExistingTitle(state);
+  const byOwner = new Map();
+  for (const candidate of candidates) {
+    const list = byOwner.get(candidate.ownerRef) ?? [];
+    list.push(candidate);
+    byOwner.set(candidate.ownerRef, list);
+  }
+  for (const [ownerRef, ownerCandidates] of byOwner) {
+    if (existing.has(ownerRef)) continue;
+    const values = uniqueStrings(
+      ownerCandidates.map((candidate) => candidate.value),
+    );
+    if (values.length !== 1) continue;
+    const matching = ownerCandidates.filter(
+      (candidate) => candidate.value === values[0],
+    );
+    const support = uniqueSupport(
+      matching.flatMap((candidate) => candidate.support),
+    );
+    if (support.length === 0) continue;
+    state.builder.addFact("ui-property", {
+      identity: [
+        { kind: "component", value: ownerRef },
+        { kind: "semantic-key", value: "title" },
+      ],
+      confidence: "high",
+      support: support,
+      data: {
+        ownerKey: ownerRef,
+        property: "title",
+        value: values[0],
+      },
+      relatedFactRefs: uniqueStrings(
+        matching.flatMap((candidate) => candidate.relatedFactRefs),
+      ),
+    });
+  }
+}