android2harmony 0.1.6 → 0.1.8

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

@@ -0,0 +1,1149 @@
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+}
+function text(value, key) {
+  const candidate = value[key];
+  return typeof candidate === "string" && candidate.trim().length > 0
+    ? candidate.trim()
+    : undefined;
+}
+function sourceKind(record) {
+  const language = text(record.data, "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 }
+        : {}),
+    },
+  };
+}
+function symbolKey(expression) {
+  const symbol = object(expression?.resolvedSymbol);
+  if (!symbol) return undefined;
+  const kind = text(symbol, "kind") ?? "";
+  const name = text(symbol, "name") ?? "";
+  const signature = text(symbol, "signature") ?? "";
+  const owner = text(symbol, "ownerQualifiedName") ?? "";
+  const type = text(symbol, "type") ?? "";
+  if (!name && !signature) return undefined;
+  const initializer = object(symbol.initializer);
+  const declarationIdentity =
+    text(symbol, "declarationRef") ??
+    text(symbol, "declarationId") ??
+    (initializer ? text(initializer, "callRef") : undefined);
+  return [
+    kind,
+    owner,
+    signature || name,
+    type,
+    ...(declarationIdentity ? [declarationIdentity] : []),
+  ].join("\u0000");
+}
+function jsonValue(expression) {
+  if (!expression || !Object.hasOwn(expression, "constantValue")) {
+    return { present: false };
+  }
+  const value = expression.constantValue;
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return { present: true, value };
+  }
+  return { present: false };
+}
+function stringValues(value) {
+  return Array.isArray(value)
+    ? value.filter(
+        (candidate) =>
+          typeof candidate === "string" && candidate.trim().length > 0,
+      )
+    : [];
+}
+function structuredConditionContexts(record) {
+  const contexts = record.data.conditionContexts;
+  if (!Array.isArray(contexts)) return [];
+  return contexts.flatMap((candidate) => {
+    const structured = object(candidate);
+    if (!structured) return [];
+    const conditionRef = text(structured, "conditionRef");
+    const branchKind = text(structured, "branchKind");
+    const polarity = text(structured, "polarity");
+    if (
+      !conditionRef ||
+      !(
+        branchKind === "then" ||
+        branchKind === "else" ||
+        branchKind === "fallthrough" ||
+        branchKind === "case"
+      ) ||
+      !(polarity === "true" || polarity === "false" || polarity === "case")
+    )
+      return [];
+    return [
+      {
+        conditionRef,
+        branchKind,
+        polarity,
+        caseValues: stringValues(structured.caseValues),
+      },
+    ];
+  });
+}
+function structuredConditionKeys(
+  record,
+  callbackRef,
+  recordsById,
+  state,
+  subject,
+) {
+  const result = new Set();
+  const covered = new Set();
+  const addCondition = (condition, expressionAnchor, plainLanguage, role) => {
+    const location = recordLocation(
+      condition,
+      `${subject}-condition:${expressionAnchor}:${condition.id}`,
+    );
+    if (!location) return;
+    result.add(
+      state.builder.addFact("condition", {
+        identity: [
+          { kind: "callback", value: callbackRef },
+          { kind: "semantic-key", value: expressionAnchor },
+        ],
+        confidence: "high",
+        support: [{ location, role }],
+        data: {
+          ownerKey: callbackRef,
+          expressionAnchor,
+          plainLanguage,
+          valueKind: "runtime",
+        },
+        relatedFactRefs: [callbackRef],
+      }),
+    );
+  };
+  for (const context of structuredConditionContexts(record)) {
+    covered.add(context.conditionRef);
+    const condition = recordsById.get(context.conditionRef);
+    const expression = condition
+      ? text(condition.data, "expression")
+      : undefined;
+    if (!condition || !expression) continue;
+    const expressionAnchor =
+      context.polarity === "false"
+        ? `!(${expression})`
+        : context.polarity === "case"
+          ? `${expression} in (${context.caseValues.join(", ")})`
+          : expression;
+    addCondition(
+      condition,
+      expressionAnchor,
+      context.polarity === "false"
+        ? `不满足条件：${expression}`
+        : context.polarity === "case"
+          ? `条件 ${expression} 匹配：${context.caseValues.join("、")}`
+          : `满足条件：${expression}`,
+      `structured ${context.branchKind} ${subject} branch ` +
+        `with ${context.polarity} polarity`,
+    );
+  }
+  for (const conditionRef of stringValues(record.data.conditionRefs)) {
+    if (covered.has(conditionRef)) continue;
+    const condition = recordsById.get(conditionRef);
+    const expression = condition
+      ? text(condition.data, "expression")
+      : undefined;
+    if (!condition || !expression) continue;
+    addCondition(
+      condition,
+      expression,
+      expression,
+      `structured condition guarding ${subject}`,
+    );
+  }
+  return [...result].sort((left, right) => left.localeCompare(right, "en"));
+}
+function assignmentValueIdentity(assignment, expression, value) {
+  if (value.present) return `constant:${JSON.stringify(value.value)}`;
+  const source = expression ? text(expression, "source") : undefined;
+  return `expression:${source ?? symbolKey(expression) ?? assignment.id}`;
+}
+function sameRawSpan(left, right) {
+  const leftLocation = left.location;
+  const rightLocation = right.location;
+  if (
+    !leftLocation ||
+    !rightLocation ||
+    leftLocation.path !== rightLocation.path
+  )
+    return false;
+  if (
+    leftLocation.startOffset >= 0 &&
+    leftLocation.endOffset >= 0 &&
+    rightLocation.startOffset >= 0 &&
+    rightLocation.endOffset >= 0
+  ) {
+    return (
+      leftLocation.startOffset === rightLocation.startOffset &&
+      leftLocation.endOffset === rightLocation.endOffset
+    );
+  }
+  return (
+    leftLocation.startLine === rightLocation.startLine &&
+    leftLocation.startColumn === rightLocation.startColumn &&
+    leftLocation.endLine === rightLocation.endLine &&
+    leftLocation.endColumn === rightLocation.endColumn
+  );
+}
+function sameStrings(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => value === right[index]);
+}
+/**
+ * Kotlin UAST may expose one property write twice: as a binary assignment and
+ * as the synthetic setter call used to implement it. The resolved-call pass
+ * has the more precise receiver and argument data. Suppress the assignment
+ * only when every structural identity field and the already-emitted effect
+ * agree; ambiguous matches are deliberately retained.
+ */
+function equivalentResolvedSetterEffect(
+  jvm,
+  assignment,
+  callbackRef,
+  conditionKeys,
+  state,
+) {
+  const left = object(assignment.data.left);
+  const symbol = object(left?.resolvedSymbol);
+  const signature =
+    symbol && text(symbol, "kind") === "method"
+      ? text(symbol, "signature")
+      : undefined;
+  const enclosingCallableRef = text(assignment.data, "enclosingCallableRef");
+  if (!signature || !enclosingCallableRef) return undefined;
+  const matches = jvm.body.flatMap((call) => {
+    if (
+      call.kind !== "resolved-call" ||
+      text(call.data, "targetSignature") !== signature ||
+      text(call.data, "enclosingCallableRef") !== enclosingCallableRef ||
+      !sameRawSpan(assignment, call)
+    )
+      return [];
+    const effectRef = state.effectForResolvedCall(call.id);
+    const effect = effectRef ? state.builder.fact(effectRef) : undefined;
+    if (
+      !effect ||
+      effect.kind !== "behavior-effect" ||
+      effect.data.callbackKey !== callbackRef ||
+      effect.data.effectKind !== "update-state" ||
+      !sameStrings(
+        [...(effect.data.conditionKeys ?? [])].sort(),
+        [...conditionKeys].sort(),
+      )
+    )
+      return [];
+    return [effectRef];
+  });
+  return matches.length === 1 ? matches[0] : undefined;
+}
+function callableRecordForCallback(jvm, state, callbackRef) {
+  return jvm.body.find(
+    (record) =>
+      (record.kind === "lambda-declaration" ||
+        record.kind === "method-declaration") &&
+      state.callbackForRawCallable(record.id) === callbackRef,
+  );
+}
+function hasEffect(state, callbackRef, effectKind, targetRef) {
+  return state.builder
+    .facts("behavior-effect")
+    .some(
+      (fact) =>
+        fact.kind === "behavior-effect" &&
+        fact.data.callbackKey === callbackRef &&
+        fact.data.effectKind === effectKind &&
+        fact.data.targetKey === targetRef,
+    );
+}
+function addInteractionIntrinsicEffects(jvm, state) {
+  for (const binding of state.builder.facts("interaction-binding")) {
+    if (binding.kind !== "interaction-binding") continue;
+    const effectKind =
+      binding.data.trigger === "text-input"
+        ? "input"
+        : binding.data.trigger === "toggle"
+          ? "update-state"
+          : undefined;
+    if (!effectKind || hasEffect(state, binding.data.callbackKey, effectKind))
+      continue;
+    const callable = callableRecordForCallback(
+      jvm,
+      state,
+      binding.data.callbackKey,
+    );
+    const location = callable
+      ? recordLocation(
+          callable,
+          `interaction-effect:${binding.data.trigger}:${callable.id}`,
+        )
+      : undefined;
+    if (!location) continue;
+    state.builder.addFact("behavior-effect", {
+      identity: [
+        { kind: "callback", value: binding.data.callbackKey },
+        { kind: "semantic-key", value: effectKind },
+        { kind: "semantic-key", value: binding.id },
+      ],
+      confidence: binding.confidence,
+      support: [
+        {
+          location,
+          role:
+            binding.data.trigger === "text-input"
+              ? "resolved text-input interaction"
+              : "resolved toggle interaction",
+        },
+      ],
+      data: {
+        callbackKey: binding.data.callbackKey,
+        effectKind,
+      },
+      relatedFactRefs: [binding.data.callbackKey, binding.id],
+    });
+  }
+}
+function surfaceConditionOwners(jvm, state) {
+  const surfaceTypes = new Set([
+    "dialog",
+    "drawer",
+    "bottom-sheet",
+    "overlay",
+    "pager",
+    "pager-page",
+    "inline-detail-surface",
+    "popup",
+  ]);
+  const conditionFacts = state.builder.facts("condition");
+  const owners = new Map();
+  for (const raw of jvm.body) {
+    if (raw.kind !== "condition") continue;
+    const expression = text(raw.data, "expression");
+    const structure = object(raw.data.expressionStructure);
+    const key = symbolKey(structure);
+    if (!expression || !key) continue;
+    for (const fact of conditionFacts) {
+      if (
+        fact.kind !== "condition" ||
+        fact.data.expressionAnchor !== expression
+      )
+        continue;
+      const owner = state.builder.fact(fact.data.ownerKey);
+      if (
+        owner?.kind !== "component" ||
+        !surfaceTypes.has(owner.data.componentType)
+      )
+        continue;
+      const values = owners.get(key) ?? new Set();
+      values.add(owner.id);
+      owners.set(key, values);
+    }
+  }
+  return new Map(
+    [...owners].map(([key, values]) => [
+      key,
+      [...values].sort((left, right) => left.localeCompare(right, "en")),
+    ]),
+  );
+}
+function addAssignmentEffects(jvm, state) {
+  const recordsById = new Map(jvm.body.map((record) => [record.id, record]));
+  const surfacesByState = surfaceConditionOwners(jvm, state);
+  const interactions = state.builder.facts("interaction-binding");
+  for (const assignment of jvm.body) {
+    if (assignment.kind !== "assignment") continue;
+    const rawCallableRef = text(assignment.data, "enclosingCallableRef");
+    const callbackRef = rawCallableRef
+      ? state.callbackForRawCallable(rawCallableRef)
+      : undefined;
+    const location = recordLocation(
+      assignment,
+      `assignment-effect:${assignment.id}`,
+    );
+    if (!callbackRef || !location) continue;
+    const left = object(assignment.data.left);
+    const right = object(assignment.data.right);
+    const stateSymbol = symbolKey(left);
+    const value = jsonValue(right);
+    const conditionKeys = structuredConditionKeys(
+      assignment,
+      callbackRef,
+      recordsById,
+      state,
+      "assignment",
+    );
+    const valueIdentity = assignmentValueIdentity(assignment, right, value);
+    const surfaceRefs = stateSymbol
+      ? (surfacesByState.get(stateSymbol) ?? [])
+      : [];
+    const registeredSurfaces = stateSymbol
+      ? state.conditionalSurfacesByStateSymbol.get(stateSymbol)
+      : undefined;
+    const booleanValue =
+      value.present && typeof value.value === "boolean"
+        ? value.value
+        : undefined;
+    const candidates = new Map();
+    if (surfaceRefs.length === 1 && booleanValue !== undefined) {
+      candidates.set(surfaceRefs[0], {
+        effectKind: booleanValue ? "show-surface" : "close-surface",
+        confidence: "high",
+      });
+    }
+    if (registeredSurfaces?.size === 1) {
+      const [targetRef, activation] = [...registeredSurfaces][0];
+      if (activation === "boolean-true" && booleanValue !== undefined) {
+        candidates.set(targetRef, {
+          effectKind: booleanValue ? "show-surface" : "close-surface",
+          confidence: "high",
+        });
+      } else if (activation === "non-null") {
+        if (value.present) {
+          candidates.set(targetRef, {
+            effectKind: value.value === null ? "close-surface" : "show-surface",
+            confidence: "high",
+          });
+        } else if (
+          object(right?.resolvedSymbol) ||
+          object(right?.resourceReference) ||
+          text(right ?? {}, "callRef")
+        ) {
+          /*
+           * A resolved non-constant expression can still be nullable at
+           * runtime. It is valid evidence that the assignment may activate
+           * the safe-call surface, but not proof that it always does.
+           */
+          candidates.set(targetRef, {
+            effectKind: "show-surface",
+            confidence: "medium",
+          });
+        }
+      }
+    }
+    if (candidates.size === 1) {
+      const [targetRef, candidate] = [...candidates][0];
+      const effectKind = candidate.effectKind;
+      state.builder.addFact("behavior-effect", {
+        identity: [
+          { kind: "callback", value: callbackRef },
+          { kind: "semantic-key", value: effectKind },
+          { kind: "component", value: targetRef },
+          { kind: "semantic-key", value: stateSymbol ?? assignment.id },
+          { kind: "semantic-key", value: valueIdentity },
+          {
+            kind: "semantic-key",
+            value: `conditions:${conditionKeys.join("|")}`,
+          },
+        ],
+        confidence: candidate.confidence,
+        support: [
+          {
+            location,
+            role: "structured assignment to Compose surface activation state",
+          },
+        ],
+        data: {
+          callbackKey: callbackRef,
+          effectKind,
+          targetKey: targetRef,
+          ...(stateSymbol ? { stateKey: stateSymbol } : {}),
+          ...(value.present ? { value: value.value ?? null } : {}),
+          conditionKeys,
+        },
+        relatedFactRefs: [callbackRef, targetRef, ...conditionKeys],
+      });
+      continue;
+    }
+    if (
+      equivalentResolvedSetterEffect(
+        jvm,
+        assignment,
+        callbackRef,
+        conditionKeys,
+        state,
+      )
+    )
+      continue;
+    const binding = interactions.find(
+      (fact) =>
+        fact.kind === "interaction-binding" &&
+        fact.data.callbackKey === callbackRef,
+    );
+    if (
+      !binding ||
+      binding.kind !== "interaction-binding" ||
+      binding.data.trigger === "toggle" ||
+      binding.data.trigger === "text-input"
+    )
+      continue;
+    state.builder.addFact("behavior-effect", {
+      identity: [
+        { kind: "callback", value: callbackRef },
+        { kind: "semantic-key", value: "update-state" },
+        { kind: "semantic-key", value: stateSymbol ?? assignment.id },
+        { kind: "semantic-key", value: valueIdentity },
+        {
+          kind: "semantic-key",
+          value: `conditions:${conditionKeys.join("|")}`,
+        },
+      ],
+      confidence: stateSymbol ? "high" : "medium",
+      support: [
+        {
+          location,
+          role: "structured state assignment inside interaction callback",
+        },
+      ],
+      data: {
+        callbackKey: callbackRef,
+        effectKind: "update-state",
+        ...(stateSymbol ? { stateKey: stateSymbol } : {}),
+        ...(value.present ? { value: value.value ?? null } : {}),
+        conditionKeys,
+      },
+      relatedFactRefs: [callbackRef, binding.id, ...conditionKeys],
+    });
+  }
+}
+const composeSurfaceStateOwners = new Set([
+  "androidx.compose.material.DrawerState",
+  "androidx.compose.material.ModalBottomSheetState",
+  "androidx.compose.material3.DrawerState",
+  "androidx.compose.material3.SheetState",
+]);
+function stateApiEffectKind(call) {
+  if (call.kind !== "resolved-call") return undefined;
+  const owner = text(call.data, "targetOwnerQualifiedName");
+  if (!owner || !composeSurfaceStateOwners.has(owner)) return undefined;
+  const name = text(call.data, "targetName");
+  if (
+    name === "open" ||
+    name === "show" ||
+    name === "expand" ||
+    name === "partialExpand"
+  ) {
+    return "show-surface";
+  }
+  return name === "close" || name === "hide" ? "close-surface" : undefined;
+}
+function stateApiReceiverSymbol(call) {
+  const receiverExpression = object(call.data.receiverExpression);
+  const fromExpression = symbolKey(receiverExpression);
+  if (fromExpression) return fromExpression;
+  const receiverSymbol = object(call.data.receiverResolvedSymbol);
+  return receiverSymbol
+    ? symbolKey({ resolvedSymbol: receiverSymbol })
+    : undefined;
+}
+function effectCallbackForCall(jvm, state, call) {
+  const parents = new Map();
+  for (const record of jvm.body) {
+    if (
+      record.kind !== "lambda-declaration" &&
+      record.kind !== "method-declaration"
+    )
+      continue;
+    const parent = text(record.data, "enclosingCallableRef");
+    if (parent) parents.set(record.id, parent);
+  }
+  const interactionCallbacks = new Set(
+    state.builder
+      .facts("interaction-binding")
+      .flatMap((fact) =>
+        fact.kind === "interaction-binding" ? [fact.data.callbackKey] : [],
+      ),
+  );
+  const visited = new Set();
+  let rawCallable = text(call.data, "enclosingCallableRef");
+  let nearest;
+  while (rawCallable && !visited.has(rawCallable)) {
+    visited.add(rawCallable);
+    const callbackRef = state.callbackForRawCallable(rawCallable);
+    if (callbackRef) {
+      nearest ??= callbackRef;
+      if (interactionCallbacks.has(callbackRef)) return callbackRef;
+    }
+    rawCallable = parents.get(rawCallable);
+  }
+  return nearest;
+}
+function addComposeSurfaceStateEffects(jvm, state) {
+  for (const call of jvm.body) {
+    const stateSymbol = stateApiReceiverSymbol(call);
+    const targetSignature = text(call.data, "targetSignature");
+    const registeredEffect =
+      stateSymbol && targetSignature
+        ? state.statefulSurfaceTransition(stateSymbol, targetSignature)
+        : undefined;
+    const effectKind = registeredEffect ?? stateApiEffectKind(call);
+    const surfaces = stateSymbol
+      ? state.statefulSurfacesByStateSymbol.get(stateSymbol)
+      : undefined;
+    if (!effectKind || !surfaces || surfaces.size !== 1) continue;
+    const callbackRef = effectCallbackForCall(jvm, state, call);
+    const location = recordLocation(
+      call,
+      `compose-surface-state:${text(call.data, "targetSignature") ?? call.id}`,
+    );
+    if (!callbackRef || !location) continue;
+    const [surfaceRef] = [...surfaces];
+    if (hasEffect(state, callbackRef, effectKind, surfaceRef)) continue;
+    state.builder.addFact("behavior-effect", {
+      identity: [
+        { kind: "callback", value: callbackRef },
+        { kind: "semantic-key", value: effectKind },
+        { kind: "component", value: surfaceRef },
+      ],
+      confidence: "high",
+      support: [
+        {
+          location,
+          role: "resolved Compose surface-state API",
+        },
+      ],
+      data: {
+        callbackKey: callbackRef,
+        effectKind,
+        targetKey: surfaceRef,
+      },
+      relatedFactRefs: [callbackRef, surfaceRef],
+    });
+  }
+}
+const composeSnackbarHostOwners = new Set([
+  "androidx.compose.material.SnackbarHostState",
+  "androidx.compose.material3.SnackbarHostState",
+]);
+const composeSnackbarOwners = new Set([
+  "androidx.compose.material.SnackbarKt",
+  "androidx.compose.material3.SnackbarKt",
+]);
+const composeTextOwners = new Set([
+  "androidx.compose.material.TextKt",
+  "androidx.compose.material3.TextKt",
+]);
+function numeric(value, key) {
+  const candidate = value[key];
+  return typeof candidate === "number" && Number.isFinite(candidate)
+    ? candidate
+    : undefined;
+}
+function callBindings(jvm, callRef) {
+  return jvm.body.filter(
+    (record) =>
+      record.kind === "call-argument-binding" &&
+      text(record.data, "callRef") === callRef,
+  );
+}
+function preferredBinding(jvm, callRef, parameterNames, fallbackIndex) {
+  const candidates = callBindings(jvm, callRef).filter(
+    (binding) => object(binding.data.expression) !== undefined,
+  );
+  return (
+    candidates.find((binding) =>
+      parameterNames.has(text(binding.data, "parameterName") ?? ""),
+    ) ??
+    candidates.find(
+      (binding) => numeric(binding.data, "argumentIndex") === fallbackIndex,
+    )
+  );
+}
+function selectedStringResource(resourceName, state) {
+  const candidates = state.builder
+    .facts("resource-value")
+    .flatMap((fact) =>
+      fact.kind === "resource-value" &&
+      fact.data.resourceType === "string" &&
+      fact.data.resourceName === resourceName &&
+      typeof fact.data.value === "string"
+        ? [{ ref: fact.id, value: fact.data.value }]
+        : [],
+    );
+  const values = [...new Set(candidates.map((candidate) => candidate.value))];
+  if (values.length !== 1) {
+    return {
+      present: false,
+      expression: `R.string.${resourceName}`,
+      resourceFactRefs: [],
+    };
+  }
+  return {
+    present: true,
+    value: values[0],
+    resourceFactRefs: candidates
+      .filter((candidate) => candidate.value === values[0])
+      .map((candidate) => candidate.ref)
+      .sort((left, right) => left.localeCompare(right, "en")),
+  };
+}
+function resourceMessage(expression, state) {
+  const resource = object(expression.resourceReference);
+  const resourceName = resource ? text(resource, "resourceName") : undefined;
+  if (resource && text(resource, "resourceType") === "string" && resourceName) {
+    return selectedStringResource(resourceName, state);
+  }
+  return undefined;
+}
+function isResolvedStringResourceCall(call) {
+  const owner = text(call.data, "targetOwnerQualifiedName") ?? "";
+  const name = text(call.data, "targetName") ?? "";
+  return (
+    (owner === "androidx.compose.ui.res.StringResources_androidKt" &&
+      name === "stringResource") ||
+    ((owner === "android.content.Context" ||
+      owner === "android.content.res.Resources") &&
+      name === "getString")
+  );
+}
+function feedbackMessageExpression(
+  expression,
+  evidenceRecord,
+  jvm,
+  state,
+  visitedCalls,
+) {
+  if (
+    Object.hasOwn(expression, "constantValue") &&
+    typeof expression.constantValue === "string"
+  ) {
+    return {
+      present: true,
+      value: expression.constantValue,
+      resourceFactRefs: [],
+      evidenceRecord,
+    };
+  }
+  const resource = resourceMessage(expression, state);
+  if (resource) return { ...resource, evidenceRecord };
+  const resolvedSymbol = object(expression.resolvedSymbol);
+  const initializer = object(resolvedSymbol?.initializer);
+  if (initializer) {
+    const initialized = feedbackMessageExpression(
+      initializer,
+      evidenceRecord,
+      jvm,
+      state,
+      visitedCalls,
+    );
+    if (initialized.present) return initialized;
+  }
+  const directCallRef = text(expression, "callRef");
+  const initializerCallRef = initializer
+    ? text(initializer, "callRef")
+    : undefined;
+  const callRef = directCallRef ?? initializerCallRef;
+  if (callRef && !visitedCalls.has(callRef)) {
+    visitedCalls.add(callRef);
+    const call = jvm.body.find((record) => record.id === callRef);
+    if (call && isResolvedStringResourceCall(call)) {
+      const binding = preferredBinding(
+        jvm,
+        call.id,
+        new Set(["id", "resId"]),
+        0,
+      );
+      const nested = object(binding?.data.expression);
+      if (binding && nested) {
+        const resolved = feedbackMessageExpression(
+          nested,
+          binding,
+          jvm,
+          state,
+          visitedCalls,
+        );
+        if (resolved.present) return resolved;
+      }
+    }
+  }
+  return {
+    present: false,
+    ...(text(expression, "source")
+      ? { expression: text(expression, "source") }
+      : {}),
+    resourceFactRefs: [],
+    evidenceRecord,
+  };
+}
+function feedbackMessage(binding, jvm, state, fallbackExpression) {
+  const expression = object(binding?.data.expression);
+  if (!binding || !expression) {
+    return {
+      present: false,
+      ...(fallbackExpression ? { expression: fallbackExpression } : {}),
+      resourceFactRefs: [],
+      ...(binding ? { evidenceRecord: binding } : {}),
+    };
+  }
+  const resolution = feedbackMessageExpression(
+    expression,
+    binding,
+    jvm,
+    state,
+    new Set(),
+  );
+  return resolution.expression || !fallbackExpression
+    ? resolution
+    : { ...resolution, expression: fallbackExpression };
+}
+function addComposeFeedbackEffect(
+  state,
+  callbackRef,
+  apiIdentity,
+  origin,
+  message,
+  supports,
+  conditionKeys,
+  stateKey,
+) {
+  const support = supports.flatMap(({ record, role }) => {
+    const location = recordLocation(
+      record,
+      `compose-feedback:${apiIdentity}:${record.id}`,
+    );
+    return location ? [{ location, role }] : [];
+  });
+  if (support.length === 0) return;
+  const messageIdentity = message.present
+    ? `value:${JSON.stringify(message.value)}`
+    : `expression:${message.expression ?? origin.id}`;
+  const effectRef = state.builder.addFact("behavior-effect", {
+    identity: [
+      { kind: "callback", value: callbackRef },
+      { kind: "semantic-key", value: `compose-feedback:${apiIdentity}` },
+      { kind: "semantic-key", value: stateKey ?? "stateless" },
+      { kind: "semantic-key", value: messageIdentity },
+      {
+        kind: "semantic-key",
+        value: `conditions:${conditionKeys.join("|")}`,
+      },
+    ],
+    confidence: "high",
+    support: support,
+    data: {
+      callbackKey: callbackRef,
+      effectKind: "show-feedback",
+      ...(stateKey ? { stateKey } : {}),
+      ...(message.present ? { value: message.value ?? "" } : {}),
+      conditionKeys,
+    },
+    relatedFactRefs: [
+      callbackRef,
+      ...message.resourceFactRefs,
+      ...conditionKeys,
+    ],
+  });
+  if (message.present) return;
+  const fact = state.builder.fact(effectRef);
+  const evidenceRefs = fact?.support.map((item) => item.evidenceRef) ?? [];
+  const candidateSupport = message.evidenceRecord
+    ? recordLocation(
+        message.evidenceRecord,
+        `compose-feedback-expression:${message.evidenceRecord.id}`,
+      )
+    : undefined;
+  const candidateEvidenceRef = candidateSupport
+    ? state.builder.addEvidence(candidateSupport)
+    : undefined;
+  state.builder.addUnresolved({
+    ownerRef: effectRef,
+    fieldPath: "data.value",
+    reasonCode: "INTRINSIC_COMPOSE_FEEDBACK_TEXT_UNKNOWN",
+    message:
+      "Compose Snackbar feedback is structurally proven, but its runtime " +
+      "message text is not a unique static value.",
+    evidenceRefs,
+    candidates: message.expression
+      ? [
+          {
+            value: message.expression,
+            supportRefs: candidateEvidenceRef
+              ? [candidateEvidenceRef]
+              : evidenceRefs,
+            note: "Source expression retained as evidence; not asserted as text.",
+          },
+        ]
+      : [],
+    impact: ["req-feature-effect"],
+    originRef: origin.id,
+  });
+}
+function addSnackbarHostStateEffects(jvm, state) {
+  const recordsById = new Map(jvm.body.map((record) => [record.id, record]));
+  for (const call of jvm.body) {
+    if (
+      call.kind !== "resolved-call" ||
+      text(call.data, "targetName") !== "showSnackbar" ||
+      !composeSnackbarHostOwners.has(
+        text(call.data, "targetOwnerQualifiedName") ?? "",
+      )
+    )
+      continue;
+    const callbackRef = effectCallbackForCall(jvm, state, call);
+    if (!callbackRef) continue;
+    const binding = preferredBinding(jvm, call.id, new Set(["message"]), 0);
+    const message = feedbackMessage(
+      binding,
+      jvm,
+      state,
+      text(call.data, "source"),
+    );
+    const conditionKeys = structuredConditionKeys(
+      call,
+      callbackRef,
+      recordsById,
+      state,
+      "feedback",
+    );
+    addComposeFeedbackEffect(
+      state,
+      callbackRef,
+      text(call.data, "targetSignature") ??
+        `${text(call.data, "targetOwnerQualifiedName")}#showSnackbar`,
+      call,
+      message,
+      [{ record: call, role: "resolved SnackbarHostState.showSnackbar call" }],
+      conditionKeys,
+      stateApiReceiverSymbol(call),
+    );
+  }
+}
+function lambdaParentCalls(jvm) {
+  const result = new Map();
+  for (const binding of jvm.body) {
+    if (binding.kind !== "call-argument-binding") continue;
+    const callRef = text(binding.data, "callRef");
+    const expression = object(binding.data.expression);
+    const callableRef = expression
+      ? text(expression, "callableRef")
+      : undefined;
+    if (!callRef || !callableRef) continue;
+    const calls = result.get(callableRef) ?? new Set();
+    calls.add(callRef);
+    result.set(callableRef, calls);
+  }
+  return result;
+}
+function nearestLetCall(call, recordsById, parentCalls) {
+  let callableRef = text(call.data, "enclosingCallableRef");
+  const visited = new Set();
+  while (callableRef && !visited.has(callableRef)) {
+    visited.add(callableRef);
+    const parentRefs = [...(parentCalls.get(callableRef) ?? [])];
+    if (parentRefs.length === 1) {
+      const parent = recordsById.get(parentRefs[0]);
+      if (
+        parent?.kind === "resolved-call" &&
+        /^kotlin\.StandardKt(?:__StandardKt)?$/u.test(
+          text(parent.data, "targetOwnerQualifiedName") ?? "",
+        ) &&
+        text(parent.data, "targetName") === "let"
+      )
+        return parent;
+      callableRef = parent
+        ? text(parent.data, "enclosingCallableRef")
+        : undefined;
+      continue;
+    }
+    callableRef = text(
+      recordsById.get(callableRef)?.data ?? {},
+      "enclosingCallableRef",
+    );
+  }
+  return undefined;
+}
+function letReceiverStateKey(call, jvm) {
+  const direct = object(call.data.receiverResolvedSymbol);
+  const directKey = direct ? symbolKey({ resolvedSymbol: direct }) : undefined;
+  if (directKey) return directKey;
+  const receiver = preferredBinding(jvm, call.id, new Set(["$this$let"]), 1);
+  return symbolKey(object(receiver?.data.expression));
+}
+function provablyNonNull(assignment) {
+  const right = object(assignment.data.right);
+  const value = jsonValue(right);
+  if (value.present) return value.value !== null;
+  if (!right || sourceKind(assignment) !== "kotlin") return false;
+  const type = text(right, "expressionType");
+  if (!type || type === "null" || type.endsWith("?")) return false;
+  return Boolean(
+    object(right.resolvedSymbol) ||
+    object(right.resourceReference) ||
+    text(right, "callRef"),
+  );
+}
+function callableWithin(callableRef, ancestorRef, recordsById) {
+  const visited = new Set();
+  let current = callableRef;
+  while (current && !visited.has(current)) {
+    if (current === ancestorRef) return true;
+    visited.add(current);
+    current = text(
+      recordsById.get(current)?.data ?? {},
+      "enclosingCallableRef",
+    );
+  }
+  return false;
+}
+function composableSnackbarMessage(snackbar, jvm, state, recordsById) {
+  const contentBinding = preferredBinding(
+    jvm,
+    snackbar.id,
+    new Set(["content"]),
+    0,
+  );
+  const contentExpression = object(contentBinding?.data.expression);
+  const contentCallable = contentExpression
+    ? text(contentExpression, "callableRef")
+    : undefined;
+  if (!contentCallable) {
+    return feedbackMessage(
+      undefined,
+      jvm,
+      state,
+      contentExpression ? text(contentExpression, "source") : undefined,
+    );
+  }
+  const textCalls = jvm.body.filter(
+    (candidate) =>
+      candidate.kind === "resolved-call" &&
+      composeTextOwners.has(
+        text(candidate.data, "targetOwnerQualifiedName") ?? "",
+      ) &&
+      (text(candidate.data, "targetName") ?? "").startsWith("Text") &&
+      callableWithin(
+        text(candidate.data, "enclosingCallableRef"),
+        contentCallable,
+        recordsById,
+      ),
+  );
+  if (textCalls.length !== 1) {
+    return feedbackMessage(
+      contentBinding,
+      jvm,
+      state,
+      contentExpression ? text(contentExpression, "source") : undefined,
+    );
+  }
+  const textBinding = preferredBinding(
+    jvm,
+    textCalls[0].id,
+    new Set(["text"]),
+    0,
+  );
+  return feedbackMessage(
+    textBinding,
+    jvm,
+    state,
+    text(textCalls[0].data, "source"),
+  );
+}
+function addComposableSnackbarEffects(jvm, state) {
+  const recordsById = new Map(jvm.body.map((record) => [record.id, record]));
+  const parentCalls = lambdaParentCalls(jvm);
+  for (const snackbar of jvm.body) {
+    if (
+      snackbar.kind !== "resolved-call" ||
+      text(snackbar.data, "targetName") !== "Snackbar" ||
+      !composeSnackbarOwners.has(
+        text(snackbar.data, "targetOwnerQualifiedName") ?? "",
+      )
+    )
+      continue;
+    const letCall = nearestLetCall(snackbar, recordsById, parentCalls);
+    const stateKey = letCall ? letReceiverStateKey(letCall, jvm) : undefined;
+    if (!letCall || !stateKey) continue;
+    const message = composableSnackbarMessage(
+      snackbar,
+      jvm,
+      state,
+      recordsById,
+    );
+    for (const assignment of jvm.body) {
+      if (
+        assignment.kind !== "assignment" ||
+        symbolKey(object(assignment.data.left)) !== stateKey ||
+        !provablyNonNull(assignment)
+      )
+        continue;
+      const callbackRef = effectCallbackForCall(jvm, state, assignment);
+      if (!callbackRef) continue;
+      const conditionKeys = structuredConditionKeys(
+        assignment,
+        callbackRef,
+        recordsById,
+        state,
+        "feedback",
+      );
+      addComposeFeedbackEffect(
+        state,
+        callbackRef,
+        text(snackbar.data, "targetSignature") ??
+          `${text(snackbar.data, "targetOwnerQualifiedName")}#Snackbar`,
+        snackbar,
+        message,
+        [
+          {
+            record: assignment,
+            role: "structured non-null assignment activates Snackbar state",
+          },
+          {
+            record: snackbar,
+            role: "resolved Compose Snackbar presentation",
+          },
+        ],
+        conditionKeys,
+        stateKey,
+      );
+    }
+  }
+}
+function addComposeFeedbackEffects(jvm, state) {
+  addSnackbarHostStateEffects(jvm, state);
+  addComposableSnackbarEffects(jvm, state);
+}
+/**
+ * Adds interaction effects that are intrinsic to a resolved UI API and then
+ * classifies structured assignments. It never parses assignment source text.
+ */
+export function normalizeInteractionEffects(jvm, state) {
+  if (!jvm) return;
+  addInteractionIntrinsicEffects(jvm, state);
+  addAssignmentEffects(jvm, state);
+  addComposeSurfaceStateEffects(jvm, state);
+  addComposeFeedbackEffects(jvm, state);
+}