android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/dynamic-repeated-call-sites.js

@@ -0,0 +1,529 @@
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+}
+function text(record, key) {
+  const value = record.data[key];
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+function expression(binding) {
+  return object(binding.data.expression) ?? {};
+}
+function expressionText(binding, key) {
+  const value = expression(binding)[key];
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+function sourceApiName(record) {
+  return text(record, "targetName")?.replace(/-.*$/u, "");
+}
+function normalizedSource(value) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+function bindingParameterName(binding) {
+  return (
+    text(binding, "parameterName") ??
+    (typeof expression(binding).namedArgument === "string"
+      ? String(expression(binding).namedArgument).trim() || undefined
+      : undefined)
+  );
+}
+function callbackLike(binding) {
+  return (
+    binding.data.isLambda === true ||
+    expressionText(binding, "callableRef") !== undefined ||
+    expressionText(binding, "callableReferenceRef") !== undefined
+  );
+}
+function append(map, key, value) {
+  const records = map.get(key) ?? [];
+  records.push(value);
+  map.set(key, records);
+}
+function isComposableDeclaration(record) {
+  if (record.kind !== "method-declaration") return false;
+  if (record.data.composable === true) return true;
+  return (
+    Array.isArray(record.data.annotations) &&
+    record.data.annotations.includes("androidx.compose.runtime.Composable")
+  );
+}
+function composableQualifiedName(record) {
+  const owner = text(record, "ownerQualifiedName");
+  const name = text(record, "name");
+  return name ? (owner ? `${owner}#${name}` : name) : undefined;
+}
+function buildIndex(jvm) {
+  const recordsById = new Map();
+  const calls = [];
+  const mutableBindings = new Map();
+  const callableParent = new Map();
+  const methodsBySignature = new Map();
+  const mutableByName = new Map();
+  for (const record of jvm.body) {
+    recordsById.set(record.id, record);
+    if (record.kind === "resolved-call") calls.push(record);
+    if (record.kind === "call-argument-binding") {
+      const callRef = text(record, "callRef");
+      if (callRef) append(mutableBindings, callRef, record);
+    }
+    if (
+      record.kind === "method-declaration" ||
+      record.kind === "lambda-declaration"
+    ) {
+      const parent = text(record, "enclosingCallableRef");
+      if (parent) callableParent.set(record.id, parent);
+    }
+  }
+  for (const record of jvm.body) {
+    if (!isComposableDeclaration(record)) continue;
+    const qualifiedName = composableQualifiedName(record);
+    const signature = text(record, "signature") ?? qualifiedName;
+    if (!qualifiedName || !signature) continue;
+    const method = { record, signature, qualifiedName };
+    methodsBySignature.set(signature, method);
+    const candidates = mutableByName.get(qualifiedName) ?? [];
+    candidates.push(method);
+    mutableByName.set(qualifiedName, candidates);
+  }
+  return {
+    recordsById,
+    calls: calls.sort((left, right) => left.id.localeCompare(right.id, "en")),
+    bindingsByCall: new Map(
+      [...mutableBindings].map(([key, values]) => [
+        key,
+        values.sort((left, right) => left.id.localeCompare(right.id, "en")),
+      ]),
+    ),
+    callableParent,
+    methodsBySignature,
+    methodsByQualifiedName: new Map(
+      [...mutableByName].map(([key, values]) => [
+        key,
+        values.sort((left, right) =>
+          left.signature.localeCompare(right.signature, "en"),
+        ),
+      ]),
+    ),
+  };
+}
+function bindingsFor(index, callRef) {
+  return index.bindingsByCall.get(callRef) ?? [];
+}
+function bindingForParameter(index, callRef, parameterName) {
+  const candidates = bindingsFor(index, callRef).filter(
+    (binding) => bindingParameterName(binding) === parameterName,
+  );
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function targetForCall(index, call) {
+  const signature = text(call, "targetSignature");
+  const exact = signature ? index.methodsBySignature.get(signature) : undefined;
+  if (exact) return exact;
+  if (!signature?.includes("androidx.compose.runtime.Composer")) {
+    return undefined;
+  }
+  const owner = text(call, "targetOwnerQualifiedName");
+  const name = sourceApiName(call);
+  if (!owner || !name) return undefined;
+  const candidates = index.methodsByQualifiedName.get(`${owner}#${name}`) ?? [];
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function scopeIsWithin(index, candidate, ancestor) {
+  const visited = new Set();
+  let current = candidate;
+  while (current && !visited.has(current)) {
+    if (current === ancestor) return true;
+    visited.add(current);
+    current = index.callableParent.get(current);
+  }
+  return false;
+}
+function enclosingComposable(index, callableRef) {
+  const visited = new Set();
+  let current = callableRef;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const record = index.recordsById.get(current);
+    if (record && isComposableDeclaration(record)) {
+      const signature = text(record, "signature");
+      return signature ? index.methodsBySignature.get(signature) : undefined;
+    }
+    current = index.callableParent.get(current);
+  }
+  return undefined;
+}
+function declaredParameterNames(record) {
+  const parameters = Array.isArray(record.data.parameters)
+    ? record.data.parameters
+    : [];
+  return new Set(
+    parameters.flatMap((value) => {
+      const parameter = object(value);
+      const name = parameter?.name;
+      return typeof name === "string" && name.trim().length > 0
+        ? [name.trim()]
+        : [];
+    }),
+  );
+}
+function nearestParameterDeclaration(index, callableRef, parameterName) {
+  const visited = new Set();
+  let current = callableRef;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const declaration = index.recordsById.get(current);
+    if (!declaration) return undefined;
+    if (declaredParameterNames(declaration).has(parameterName)) {
+      return declaration;
+    }
+    current = index.callableParent.get(current);
+  }
+  return undefined;
+}
+function exactParameterName(index, summary, callableRef, method) {
+  const symbol = object(summary.resolvedSymbol);
+  const name = typeof symbol?.name === "string" ? symbol.name.trim() : "";
+  if (symbol?.kind !== "parameter" || !name) return undefined;
+  return nearestParameterDeclaration(index, callableRef, name)?.id ===
+    method.record.id
+    ? name
+    : undefined;
+}
+function initializerCall(index, summary) {
+  if (!summary) return undefined;
+  const directRef =
+    typeof summary.callRef === "string" ? summary.callRef.trim() : "";
+  const direct = directRef ? index.recordsById.get(directRef) : undefined;
+  if (direct?.kind === "resolved-call") return direct;
+  const symbol = object(summary.resolvedSymbol);
+  const initializer =
+    object(symbol?.initializer) ?? object(summary.initializer);
+  const nestedRef =
+    typeof initializer?.callRef === "string" ? initializer.callRef.trim() : "";
+  const nested = nestedRef ? index.recordsById.get(nestedRef) : undefined;
+  return nested?.kind === "resolved-call" ? nested : undefined;
+}
+function isEnumEntries(call, summary) {
+  const types = [
+    text(call, "receiverType"),
+    typeof summary.expressionType === "string"
+      ? summary.expressionType.trim()
+      : undefined,
+  ];
+  if (types.some((type) => type?.startsWith("kotlin.enums.EnumEntries<"))) {
+    return true;
+  }
+  const selector = object(summary.selectorExpression);
+  const selectorSymbol = object(selector?.resolvedSymbol);
+  return (
+    (selectorSymbol?.name === "entries" ||
+      selectorSymbol?.name === "getEntries") &&
+    object(summary.receiverExpression)?.resolvedSymbol !== undefined
+  );
+}
+const knownStaticCollectionFactories = new Set([
+  "arrayListOf",
+  "listOf",
+  "mutableListOf",
+  "mutableSetOf",
+  "setOf",
+]);
+const knownEmptyCollectionFactories = new Set(["emptyList", "emptySet"]);
+function staticPopulation(index, summary) {
+  const initializer = initializerCall(index, summary);
+  if (!initializer) return undefined;
+  const owner = text(initializer, "targetOwnerQualifiedName") ?? "";
+  const name = sourceApiName(initializer);
+  if (!name || !owner.startsWith("kotlin.collections.")) return undefined;
+  if (knownEmptyCollectionFactories.has(name)) return "impossible";
+  if (!knownStaticCollectionFactories.has(name)) return undefined;
+  const count = initializer.data.argumentCount;
+  return typeof count === "number" && Number.isInteger(count)
+    ? count > 0
+      ? "unconditional"
+      : "impossible"
+    : undefined;
+}
+function availabilityFor(record, summary, fallback) {
+  const source =
+    normalizedSource(summary.source) ??
+    normalizedSource(record.data.receiverSource) ??
+    normalizedSource(record.data.argumentSource) ??
+    fallback;
+  return {
+    record,
+    expressionAnchor: `${source}.isNotEmpty()`,
+    plainLanguage: "列表中至少包含一个可操作项目",
+  };
+}
+function fixedTerm(population, record, summary, support, keyPrefix) {
+  const availability =
+    population === "conditional"
+      ? availabilityFor(record, summary, `collection:${record.id}`)
+      : undefined;
+  return {
+    key: availability
+      ? `dynamic:${availability.expressionAnchor}`
+      : `${keyPrefix}:${population}:${record.id}`,
+    population,
+    support,
+    ...(availability ? { availability } : {}),
+  };
+}
+function receiverTerm(index, call, method, support) {
+  const summary = object(call.data.receiverExpression) ?? {};
+  if (isEnumEntries(call, summary)) return undefined;
+  const parameter = exactParameterName(
+    index,
+    summary,
+    text(call, "enclosingCallableRef"),
+    method,
+  );
+  if (parameter) {
+    return {
+      key: `parameter:${method.record.id}:${parameter}`,
+      population: "conditional",
+      support,
+      parameter: { methodRef: method.record.id, name: parameter },
+      availability: availabilityFor(
+        call,
+        summary,
+        `parameter:${method.record.id}:${parameter}`,
+      ),
+    };
+  }
+  const population = staticPopulation(index, summary) ?? "conditional";
+  return fixedTerm(population, call, summary, support, "receiver");
+}
+function isResolvedCollectionIteration(call) {
+  if (call.kind !== "resolved-call") return false;
+  const name = sourceApiName(call);
+  if (name !== "forEach" && name !== "forEachIndexed") return false;
+  const owner = text(call, "targetOwnerQualifiedName") ?? "";
+  const signature = text(call, "targetSignature") ?? "";
+  return (
+    owner.startsWith("kotlin.collections.") &&
+    /(?:java\.lang\.)?Iterable/iu.test(signature)
+  );
+}
+function loopActionScope(index, call) {
+  const binding = bindingForParameter(index, call.id, "action");
+  const scope = binding ? expressionText(binding, "callableRef") : undefined;
+  return binding &&
+    binding.data.isLambda === true &&
+    text(binding, "bindingStatus") === "resolved" &&
+    scope &&
+    index.recordsById.has(scope)
+    ? { binding, scope }
+    : undefined;
+}
+function hasActionCallback(index, call) {
+  return bindingsFor(index, call.id).some((binding) => {
+    const name = bindingParameterName(binding);
+    return (
+      name !== undefined &&
+      /^on[A-Z][A-Za-z0-9]*$/u.test(name) &&
+      callbackLike(binding)
+    );
+  });
+}
+function uniqueRecords(records) {
+  return [
+    ...new Map(records.map((record) => [record.id, record])).values(),
+  ].sort((left, right) => left.id.localeCompare(right.id, "en"));
+}
+function uniqueTerms(terms) {
+  return [...new Map(terms.map((term) => [term.key, term])).values()].sort(
+    (left, right) => left.key.localeCompare(right.key, "en"),
+  );
+}
+function termsKey(terms) {
+  return uniqueTerms(terms)
+    .map((term) => term.key)
+    .join("\u0000");
+}
+function instantiateTerm(index, call, caller, term) {
+  if (!term.parameter) return term;
+  const binding = bindingForParameter(index, call.id, term.parameter.name);
+  if (!binding) return undefined;
+  const summary = expression(binding);
+  const directParameter = exactParameterName(
+    index,
+    summary,
+    text(call, "enclosingCallableRef"),
+    caller,
+  );
+  const support = uniqueRecords([...term.support, binding]);
+  if (directParameter) {
+    return {
+      key: `parameter:${caller.record.id}:${directParameter}`,
+      population: "conditional",
+      support,
+      parameter: {
+        methodRef: caller.record.id,
+        name: directParameter,
+      },
+      availability: availabilityFor(
+        binding,
+        summary,
+        `parameter:${caller.record.id}:${directParameter}`,
+      ),
+    };
+  }
+  const syntheticCall = {
+    ...call,
+    data: {
+      ...call.data,
+      receiverType: summary.expressionType,
+      receiverSource: binding.data.argumentSource,
+      receiverExpression: summary,
+    },
+  };
+  if (isEnumEntries(syntheticCall, summary)) return undefined;
+  const population = staticPopulation(index, summary) ?? "conditional";
+  return fixedTerm(population, binding, summary, support, "argument");
+}
+function aggregateContext(terms) {
+  const unique = uniqueTerms(terms);
+  if (unique.length === 0) return undefined;
+  const population = unique.some((term) => term.population === "impossible")
+    ? "impossible"
+    : unique.some((term) => term.population === "conditional")
+      ? "conditional"
+      : "unconditional";
+  return {
+    population,
+    support: uniqueRecords(unique.flatMap((term) => term.support)),
+    availabilities:
+      population === "conditional"
+        ? [
+            ...new Map(
+              unique.flatMap((term) =>
+                term.availability
+                  ? [[term.availability.expressionAnchor, term.availability]]
+                  : [],
+              ),
+            ).values(),
+          ].sort((left, right) =>
+            left.expressionAnchor.localeCompare(right.expressionAnchor, "en"),
+          )
+        : [],
+  };
+}
+/**
+ * Proves repeated local-Composable invocations from resolved Kotlin
+ * collection iteration. Recognition never depends on product symbols or
+ * variable names. A wrapper declaration is summarized only when every
+ * action-bearing call in that declaration carries the same repeated
+ * requirement, preventing one mixed-use helper from becoming globally
+ * conditional.
+ */
+export function dynamicRepeatedCallSiteContexts(jvm) {
+  const index = buildIndex(jvm);
+  const loops = index.calls.flatMap((call) => {
+    if (!isResolvedCollectionIteration(call)) return [];
+    const action = loopActionScope(index, call);
+    const method = enclosingComposable(
+      index,
+      text(call, "enclosingCallableRef"),
+    );
+    if (!action || !method) return [];
+    const term = receiverTerm(
+      index,
+      call,
+      method,
+      uniqueRecords([call, action.binding]),
+    );
+    return term ? [{ call, action, method, term }] : [];
+  });
+  const localCalls = index.calls.flatMap((call) => {
+    const target = targetForCall(index, call);
+    const caller = enclosingComposable(
+      index,
+      text(call, "enclosingCallableRef"),
+    );
+    return target && caller && hasActionCallback(index, call)
+      ? [{ call, target, caller }]
+      : [];
+  });
+  const methodsWithExternalActions = new Set(
+    index.calls.flatMap((call) => {
+      if (!hasActionCallback(index, call) || targetForCall(index, call))
+        return [];
+      const caller = enclosingComposable(
+        index,
+        text(call, "enclosingCallableRef"),
+      );
+      return caller ? [caller.record.id] : [];
+    }),
+  );
+  const callsByMethod = new Map();
+  for (const item of localCalls) {
+    const calls = callsByMethod.get(item.caller.record.id) ?? [];
+    calls.push(item);
+    callsByMethod.set(item.caller.record.id, calls);
+  }
+  const directTerms = new Map();
+  for (const item of localCalls) {
+    const enclosing = loops.filter(
+      (loop) =>
+        loop.method.record.id === item.caller.record.id &&
+        scopeIsWithin(
+          index,
+          text(item.call, "enclosingCallableRef"),
+          loop.action.scope,
+        ),
+    );
+    if (enclosing.length > 0) {
+      directTerms.set(
+        item.call.id,
+        uniqueTerms(enclosing.map((loop) => loop.term)),
+      );
+    }
+  }
+  const summaries = new Map();
+  const termsForCall = (item) => {
+    const terms = [...(directTerms.get(item.call.id) ?? [])];
+    const targetSummary = summaries.get(item.target.record.id) ?? [];
+    for (const term of targetSummary) {
+      const instantiated = instantiateTerm(index, item.call, item.caller, term);
+      if (instantiated) terms.push(instantiated);
+    }
+    return uniqueTerms(terms);
+  };
+  for (let pass = 0; pass <= index.methodsBySignature.size; pass += 1) {
+    let changed = false;
+    for (const method of index.methodsBySignature.values()) {
+      // A call-site condition is attached to every cloned control from the
+      // target. Do not summarize a mixed wrapper when it also owns a direct
+      // framework control whose availability cannot be proved here.
+      if (methodsWithExternalActions.has(method.record.id)) continue;
+      const calls = callsByMethod.get(method.record.id) ?? [];
+      if (calls.length === 0) continue;
+      const perCall = calls.map((item) => termsForCall(item));
+      if (perCall.some((terms) => terms.length === 0)) continue;
+      const keys = new Set(perCall.map((terms) => termsKey(terms)));
+      if (keys.size !== 1) continue;
+      const next = uniqueTerms(perCall[0]);
+      if (termsKey(summaries.get(method.record.id) ?? []) === termsKey(next)) {
+        continue;
+      }
+      summaries.set(method.record.id, next);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return new Map(
+    localCalls.flatMap((item) => {
+      const context = aggregateContext(termsForCall(item));
+      return context ? [[item.call.id, context]] : [];
+    }),
+  );
+}

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

@@ -0,0 +1 @@
+export { buildSourceFacts } from "./normalize.js";