android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/java/dev/reqgen/analyzer/jvm/RawAnalysisDetector.java

@@ -0,0 +1,1911 @@
+package dev.reqgen.analyzer.jvm;
+
+import com.android.resources.ResourceFolderType;
+import com.android.tools.lint.client.api.UElementHandler;
+import com.android.tools.lint.detector.api.Category;
+import com.android.tools.lint.detector.api.Context;
+import com.android.tools.lint.detector.api.Detector;
+import com.android.tools.lint.detector.api.Implementation;
+import com.android.tools.lint.detector.api.Issue;
+import com.android.tools.lint.detector.api.JavaContext;
+import com.android.tools.lint.detector.api.Scope;
+import com.android.tools.lint.detector.api.Severity;
+import com.android.tools.lint.detector.api.SourceCodeScanner;
+import com.android.tools.lint.detector.api.XmlContext;
+import com.android.tools.lint.detector.api.XmlScanner;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiCompiledFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiField;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.PsiModifier;
+import com.intellij.psi.PsiNamedElement;
+import com.intellij.psi.PsiParameter;
+import com.intellij.psi.PsiType;
+import com.intellij.psi.PsiVariable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.jetbrains.uast.UAnnotated;
+import org.jetbrains.uast.UArrayAccessExpression;
+import org.jetbrains.uast.UBinaryExpression;
+import org.jetbrains.uast.UBlockExpression;
+import org.jetbrains.uast.UCallExpression;
+import org.jetbrains.uast.UCallableReferenceExpression;
+import org.jetbrains.uast.UClass;
+import org.jetbrains.uast.UClassLiteralExpression;
+import org.jetbrains.uast.UElement;
+import org.jetbrains.uast.UExpression;
+import org.jetbrains.uast.UFile;
+import org.jetbrains.uast.UIfExpression;
+import org.jetbrains.uast.ULambdaExpression;
+import org.jetbrains.uast.ULiteralExpression;
+import org.jetbrains.uast.UMethod;
+import org.jetbrains.uast.UNamedExpression;
+import org.jetbrains.uast.UObjectLiteralExpression;
+import org.jetbrains.uast.UParameter;
+import org.jetbrains.uast.UPolyadicExpression;
+import org.jetbrains.uast.UQualifiedReferenceExpression;
+import org.jetbrains.uast.UResolvable;
+import org.jetbrains.uast.UReturnExpression;
+import org.jetbrains.uast.USwitchClauseExpression;
+import org.jetbrains.uast.USwitchExpression;
+import org.jetbrains.uast.UThrowExpression;
+import org.jetbrains.uast.UVariable;
+import org.jetbrains.uast.UastBinaryOperator;
+import org.jetbrains.uast.UastContextKt;
+import org.jetbrains.uast.UastEmptyExpression;
+import org.jetbrains.kotlin.asJava.elements.KtLightElement;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtProperty;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class RawAnalysisDetector extends Detector
+    implements SourceCodeScanner, XmlScanner {
+
+    private static final Implementation IMPLEMENTATION = new Implementation(
+        RawAnalysisDetector.class,
+        EnumSet.of(Scope.MANIFEST, Scope.RESOURCE_FILE, Scope.JAVA_FILE),
+        Scope.MANIFEST_SCOPE,
+        Scope.RESOURCE_FILE_SCOPE,
+        Scope.JAVA_FILE_SCOPE
+    );
+
+    public static final Issue ISSUE = Issue.create(
+        "ReqgenRawJvmFacts",
+        "Collect raw Java, Kotlin, and XML facts",
+        "Internal, non-diagnostic collector for the mobile-app requirement "
+            + "generation pipeline.",
+        Category.CORRECTNESS,
+        1,
+        Severity.WARNING,
+        IMPLEMENTATION
+    );
+
+    private RawRecordWriter writer;
+
+    @Override
+    public void beforeCheckRootProject(@NotNull Context context) {
+        writer = RawRecordWriter.open(context);
+    }
+
+    @Override
+    public void afterCheckRootProject(@NotNull Context context) {
+        if (writer != null) {
+            writer.close();
+            writer = null;
+        }
+    }
+
+    @NotNull
+    @Override
+    public List<Class<? extends UElement>> getApplicableUastTypes() {
+        return List.of(
+            UFile.class,
+            UClass.class,
+            UMethod.class,
+            ULambdaExpression.class,
+            UCallableReferenceExpression.class,
+            UCallExpression.class,
+            UBinaryExpression.class,
+            UIfExpression.class,
+            USwitchExpression.class,
+            UReturnExpression.class
+        );
+    }
+
+    @Nullable
+    @Override
+    public UElementHandler createUastHandler(@NotNull JavaContext context) {
+        if (writer == null || !writer.isEnabled()) {
+            return null;
+        }
+        return new SourceHandler(context);
+    }
+
+    @NotNull
+    @Override
+    public Collection<String> getApplicableElements() {
+        return XmlScanner.ALL;
+    }
+
+    @NotNull
+    @Override
+    public Collection<String> getApplicableAttributes() {
+        return XmlScanner.ALL;
+    }
+
+    @Override
+    public void visitElement(
+        @NotNull XmlContext context,
+        @NotNull Element element
+    ) {
+        if (writer == null || !writer.isEnabled()) {
+            return;
+        }
+        emitXmlSourceFile(context);
+        RawLocation location = RawLocation.from(
+            context,
+            context.getLocation(element)
+        );
+        Node parent = element.getParentNode();
+        writer.emit(
+            "xml-element",
+            location,
+            element.getTagName(),
+            RawJson.object(
+                "tagName", element.getTagName(),
+                "localName", valueOrEmpty(element.getLocalName()),
+                "namespaceUri", valueOrEmpty(element.getNamespaceURI()),
+                "parentTagName",
+                    parent instanceof Element parentElement
+                        ? parentElement.getTagName()
+                        : "",
+                "resourceFolderType", resourceFolder(context)
+            )
+        );
+    }
+
+    @Override
+    public void visitAttribute(
+        @NotNull XmlContext context,
+        @NotNull Attr attribute
+    ) {
+        if (writer == null || !writer.isEnabled()) {
+            return;
+        }
+        emitXmlSourceFile(context);
+        RawLocation location = RawLocation.from(
+            context,
+            context.getLocation(attribute)
+        );
+        writer.emit(
+            "xml-attribute",
+            location,
+            attribute.getOwnerElement().getTagName()
+                + ":"
+                + attribute.getName(),
+            RawJson.object(
+                "ownerTagName", attribute.getOwnerElement().getTagName(),
+                "qualifiedName", attribute.getName(),
+                "localName", valueOrEmpty(attribute.getLocalName()),
+                "namespaceUri", valueOrEmpty(attribute.getNamespaceURI()),
+                "value", attribute.getValue(),
+                "resourceFolderType", resourceFolder(context)
+            )
+        );
+    }
+
+    private void emitXmlSourceFile(XmlContext context) {
+        writer.emitSourceFileOnce(
+            context,
+            "xml",
+            RawJson.object(
+                "xmlKind",
+                    context.file.getName().equals("AndroidManifest.xml")
+                        ? "manifest"
+                        : "resource",
+                "resourceFolderType", resourceFolder(context)
+            )
+        );
+    }
+
+    private final class SourceHandler extends UElementHandler {
+        private final JavaContext context;
+        private final Map<PsiElement, String> variableDeclarationRefs =
+            new IdentityHashMap<>();
+
+        private SourceHandler(JavaContext context) {
+            this.context = context;
+        }
+
+        @Override
+        public void visitFile(@NotNull UFile node) {
+            writer.emitSourceFileOnce(
+                context,
+                sourceLanguage(context),
+                RawJson.object("packageName", node.getPackageName())
+            );
+        }
+
+        @Override
+        public void visitClass(@NotNull UClass node) {
+            RawLocation location = location(node);
+            List<Object> superTypes = new ArrayList<>();
+            for (PsiClass superClass : node.getSupers()) {
+                superTypes.add(valueOrEmpty(superClass.getQualifiedName()));
+            }
+            String qualifiedName = valueOrEmpty(node.getQualifiedName());
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "name", valueOrEmpty(node.getName()),
+                "qualifiedName", qualifiedName,
+                "declarationKind", classKind(node),
+                "abstract",
+                    node.hasModifierProperty(PsiModifier.ABSTRACT),
+                "final", node.hasModifierProperty(PsiModifier.FINAL),
+                "superTypes", superTypes,
+                "annotations", annotationNames(node),
+                "composable", isComposable(node)
+            );
+            putCallableScope(data, node);
+            writer.emit(
+                "class-declaration",
+                location,
+                classDiscriminator(node),
+                data
+            );
+        }
+
+        @Override
+        public void visitMethod(@NotNull UMethod node) {
+            RawLocation location = location(node);
+            PsiClass owner = node.getContainingClass();
+            List<Object> parameters = new ArrayList<>();
+            for (PsiParameter parameter
+                : node.getParameterList().getParameters()) {
+                parameters.add(
+                    RawJson.object(
+                        "name", valueOrEmpty(parameter.getName()),
+                        "type", typeName(parameter.getType()),
+                        "varArgs", parameter.isVarArgs()
+                    )
+                );
+            }
+            String ownerName = owner == null
+                ? ""
+                : valueOrEmpty(owner.getQualifiedName());
+            Set<String> superMethodSignatures = new LinkedHashSet<>();
+            for (PsiMethod superMethod : node.findSuperMethods()) {
+                superMethodSignatures.add(methodSignature(superMethod));
+            }
+            List<Object> sortedSuperMethodSignatures =
+                new ArrayList<>(superMethodSignatures);
+            sortedSuperMethodSignatures.sort((left, right) ->
+                String.valueOf(left).compareTo(String.valueOf(right))
+            );
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "name", node.getName(),
+                "ownerQualifiedName", ownerName,
+                "declarationKind",
+                    node.isConstructor() ? "constructor" : "method",
+                "returnType", typeName(node.getReturnType()),
+                "parameters", parameters,
+                "signature", methodSignature(node),
+                "abstract",
+                    node.hasModifierProperty(PsiModifier.ABSTRACT),
+                "superMethodSignatures", sortedSuperMethodSignatures,
+                "annotations", annotationNames(node),
+                "composable", isComposable(node)
+            );
+            UClass ownerDeclaration = enclosingClassDeclaration(node);
+            if (ownerDeclaration != null) {
+                data.put(
+                    "ownerClassRef",
+                    classDeclarationRef(ownerDeclaration)
+                );
+            }
+            writer.emit(
+                "method-declaration",
+                location,
+                methodSignature(node),
+                data
+            );
+        }
+
+        @Override
+        public void visitLambdaExpression(@NotNull ULambdaExpression node) {
+            List<Object> parameters = new ArrayList<>();
+            for (UParameter parameter : node.getValueParameters()) {
+                parameters.add(
+                    RawJson.object(
+                        "name", valueOrEmpty(parameter.getName()),
+                        "type", typeName(parameter.getType())
+                    )
+                );
+            }
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "source", node.asSourceString(),
+                "functionalInterfaceType",
+                    typeName(node.getFunctionalInterfaceType()),
+                "parameters", parameters,
+                "enclosingClass", enclosingClassName(node),
+                "enclosingMethod", enclosingMethodSignature(node)
+            );
+            putCallableScope(data, node);
+            writer.emit(
+                "lambda-declaration",
+                location(node),
+                lambdaDiscriminator(node),
+                data
+            );
+        }
+
+        @Override
+        public void visitCallableReferenceExpression(
+            @NotNull UCallableReferenceExpression node
+        ) {
+            PsiElement target = node.resolve();
+            UExpression qualifier = node.getQualifierExpression();
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "source", node.asSourceString(),
+                "callableName", node.getCallableName(),
+                "qualifierSource", sourceOrEmpty(qualifier),
+                "qualifierType", typeName(node.getQualifierType()),
+                "resolved", target != null
+            );
+            if (target != null) {
+                data.put("target", symbolData(target));
+            }
+            putCallableScope(data, node);
+            writer.emit(
+                "callable-reference",
+                location(node),
+                callableReferenceDiscriminator(node, target),
+                data
+            );
+        }
+
+        @Override
+        public void visitCallExpression(@NotNull UCallExpression node) {
+            PsiMethod target = node.resolve();
+            String kind = target == null
+                ? "unresolved-call"
+                : "resolved-call";
+            Map<String, Object> data = callData(node, target);
+            String callId = writer.emit(
+                kind,
+                location(node),
+                callDiscriminator(node, target),
+                data
+            );
+            if (target == null) {
+                emitUnresolvedArgumentBindings(node, callId);
+            } else {
+                emitArgumentBindings(node, target, callId);
+            }
+        }
+
+        @Override
+        public void visitBinaryExpression(@NotNull UBinaryExpression node) {
+            String operator = node.getOperator().getText();
+            if (!isAssignmentOperator(operator)) {
+                return;
+            }
+            Map<String, Object> data = numericArrayAssignmentData(
+                node,
+                operator
+            );
+            if (data == null) {
+                data = RawJson.object(
+                    "language", sourceLanguage(context),
+                    "operator", operator,
+                    "left", expressionData(node.getLeftOperand()),
+                    "right", expressionData(node.getRightOperand()),
+                    "enclosingClass", enclosingClassName(node),
+                    "enclosingMethod", enclosingMethodSignature(node),
+                    "conditionRefs", enclosingConditionRefs(node),
+                    "conditionContexts", enclosingConditionContexts(node)
+                );
+            }
+            putCallableScope(data, node);
+            writer.emit(
+                "assignment",
+                location(node),
+                operator + ":" + node.asSourceString(),
+                data
+            );
+        }
+
+        /**
+         * Numeric lookup-table initialization can contain thousands of array
+         * element assignments. Resolving every array access is expensive, and
+         * an array element has no stable scalar symbol consumed by the current
+         * data-flow analysis. Keep the assignment and its literal value while
+         * deliberately avoiding recursive resolution of either expression.
+         */
+        @Nullable
+        private Map<String, Object> numericArrayAssignmentData(
+            UBinaryExpression node,
+            String operator
+        ) {
+            if (!"=".equals(operator)) {
+                return null;
+            }
+            UExpression left = node.getLeftOperand();
+            UExpression right = node.getRightOperand();
+            if (
+                !(left instanceof UArrayAccessExpression) ||
+                !(right instanceof ULiteralExpression literal)
+            ) {
+                return null;
+            }
+            Object value = literal.getValue();
+            if (
+                !(value instanceof Number) ||
+                RawJson.isNonFiniteNumber(value)
+            ) {
+                return null;
+            }
+            return RawJson.object(
+                "language", sourceLanguage(context),
+                "operator", operator,
+                "left", RawJson.object(
+                    "kind", "array-access",
+                    "source", left.asSourceString(),
+                    "expressionType", typeName(left.getExpressionType())
+                ),
+                "right", RawJson.object(
+                    "kind", "literal",
+                    "source", right.asSourceString(),
+                    "expressionType", typeName(right.getExpressionType()),
+                    "constantValue", value
+                ),
+                "enclosingClass", enclosingClassName(node),
+                "enclosingMethod", enclosingMethodSignature(node),
+                "conditionRefs", enclosingConditionRefs(node),
+                "conditionContexts", enclosingConditionContexts(node)
+            );
+        }
+
+        @Override
+        public void visitIfExpression(@NotNull UIfExpression node) {
+            emitCondition(
+                node,
+                node.getCondition(),
+                "if",
+                node.getCondition().asSourceString()
+            );
+        }
+
+        @Override
+        public void visitSwitchExpression(@NotNull USwitchExpression node) {
+            UExpression subject = node.getExpression();
+            emitCondition(
+                node,
+                subject,
+                "switch-or-when",
+                subject == null ? node.asSourceString() : subject.asSourceString()
+            );
+        }
+
+        @Override
+        public void visitReturnExpression(@NotNull UReturnExpression node) {
+            UExpression value = node.getReturnExpression();
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "source", node.asSourceString(),
+                "enclosingClass", enclosingClassName(node),
+                "enclosingMethod", enclosingMethodSignature(node),
+                "conditionRefs", enclosingConditionRefs(node),
+                "conditionContexts", enclosingConditionContexts(node)
+            );
+            if (value != null) {
+                data.put("expression", expressionData(value));
+            }
+            putCallableScope(data, node);
+            writer.emit(
+                "return",
+                location(node),
+                node.asSourceString(),
+                data
+            );
+        }
+
+        private void emitArgumentBindings(
+            UCallExpression call,
+            PsiMethod target,
+            String callId
+        ) {
+            Map<UExpression, PsiParameter> mapping =
+                context.getEvaluator().computeArgumentMapping(call, target);
+            Set<UExpression> arguments = java.util.Collections.newSetFromMap(
+                new IdentityHashMap<>()
+            );
+            List<UExpression> orderedArguments = new ArrayList<>();
+            for (UExpression argument : call.getValueArguments()) {
+                if (arguments.add(argument)) {
+                    orderedArguments.add(argument);
+                }
+            }
+            for (UExpression argument : mapping.keySet()) {
+                if (
+                    arguments.add(argument) &&
+                    orderedArguments.stream().noneMatch(existing ->
+                        sameSource(existing, argument)
+                    )
+                ) {
+                    orderedArguments.add(argument);
+                }
+            }
+
+            PsiParameter[] parameters =
+                target.getParameterList().getParameters();
+            for (int argumentIndex = 0;
+                argumentIndex < orderedArguments.size();
+                argumentIndex += 1) {
+                UExpression argument = orderedArguments.get(argumentIndex);
+                PsiParameter parameter = mappedParameter(
+                    call,
+                    argument,
+                    mapping,
+                    parameters
+                );
+                int parameterIndex = parameterIndex(parameters, parameter);
+                emitArgumentBinding(
+                    argument,
+                    callId,
+                    argumentIndex,
+                    parameterIndex,
+                    parameter,
+                    methodSignature(target)
+                );
+            }
+        }
+
+        private void emitUnresolvedArgumentBindings(
+            UCallExpression call,
+            String callId
+        ) {
+            List<UExpression> arguments = call.getValueArguments();
+            for (int index = 0; index < arguments.size(); index += 1) {
+                emitArgumentBinding(
+                    arguments.get(index),
+                    callId,
+                    index,
+                    -1,
+                    null,
+                    ""
+                );
+            }
+        }
+
+        private void emitArgumentBinding(
+            UExpression argument,
+            String callId,
+            int argumentIndex,
+            int parameterIndex,
+            @Nullable PsiParameter parameter,
+            String targetSignature
+        ) {
+            writer.emit(
+                "call-argument-binding",
+                location(argument),
+                callId + ":" + argumentIndex + ":" + parameterIndex,
+                RawJson.object(
+                    "callRef", callId,
+                    "argumentIndex", argumentIndex,
+                    "argumentKind", expressionKind(argument),
+                    "argumentSource", argument.asSourceString(),
+                    "expression", expressionData(argument),
+                    "isLambda", containsLambda(argument),
+                    "bindingStatus",
+                        parameter == null ? "unresolved" : "resolved",
+                    "parameterIndex", parameterIndex,
+                    "parameterName",
+                        parameter == null
+                            ? ""
+                            : valueOrEmpty(parameter.getName()),
+                    "parameterType",
+                        parameter == null
+                            ? ""
+                            : typeName(parameter.getType()),
+                    "parameterVarArgs",
+                        parameter != null && parameter.isVarArgs(),
+                    "targetSignature", targetSignature
+                )
+            );
+        }
+
+        private Map<String, Object> callData(
+            UCallExpression call,
+            @Nullable PsiMethod target
+        ) {
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "methodName", valueOrEmpty(call.getMethodName()),
+                "callKind", String.valueOf(call.getKind()),
+                "source", call.asSourceString(),
+                "receiverType", typeName(call.getReceiverType()),
+                "receiverAccess", receiverAccess(call),
+                "argumentCount", call.getValueArgumentCount(),
+                "enclosingClass", enclosingClassName(call),
+                "enclosingMethod", enclosingMethodSignature(call),
+                "conditionRefs", enclosingConditionRefs(call),
+                "conditionContexts", enclosingConditionContexts(call)
+            );
+            UExpression receiver = call.getReceiver();
+            if (receiver != null) {
+                data.put("receiverSource", receiver.asSourceString());
+                data.put("receiverExpression", expressionData(receiver));
+                PsiElement resolvedReceiver = resolveExpression(receiver);
+                if (resolvedReceiver != null) {
+                    data.put(
+                        "receiverResolvedSymbol",
+                        symbolData(resolvedReceiver)
+                    );
+                }
+            }
+            putCallableScope(data, call);
+            if (target != null) {
+                PsiClass owner = target.getContainingClass();
+                data.put(
+                    "targetOwnerQualifiedName",
+                    owner == null
+                        ? ""
+                        : valueOrEmpty(owner.getQualifiedName())
+                );
+                data.put("targetName", target.getName());
+                data.put("targetSignature", methodSignature(target));
+                data.put("targetConstructor", target.isConstructor());
+            }
+            return data;
+        }
+
+        private String receiverAccess(UCallExpression call) {
+            UElement current = call;
+            UElement parent = current.getUastParent();
+            while (parent instanceof UQualifiedReferenceExpression qualified) {
+                if (isWithin(current, qualified.getSelector())) {
+                    String name = qualified.getAccessType().getName();
+                    if ("?.".equals(name)) {
+                        return "safe";
+                    }
+                    if (".".equals(name)) {
+                        return "simple";
+                    }
+                    return name == null ? "" : name.toLowerCase();
+                }
+                current = parent;
+                parent = current.getUastParent();
+            }
+            return "";
+        }
+
+        private Map<String, Object> expressionData(UExpression expression) {
+            if (expression instanceof UNamedExpression namedExpression) {
+                Map<String, Object> result = expressionData(
+                    namedExpression.getExpression()
+                );
+                result.put(
+                    "namedArgument",
+                    valueOrEmpty(namedExpression.getName())
+                );
+                return result;
+            }
+
+            Map<String, Object> result = RawJson.object(
+                "kind", expressionKind(expression),
+                "source", expression.asSourceString(),
+                "expressionType", typeName(expression.getExpressionType())
+            );
+            if (expression instanceof UBinaryExpression binary) {
+                result.put("operator", binary.getOperator().getText());
+                result.put(
+                    "left",
+                    expressionData(binary.getLeftOperand())
+                );
+                result.put(
+                    "right",
+                    expressionData(binary.getRightOperand())
+                );
+            }
+            if (expression instanceof UIfExpression conditional) {
+                /*
+                 * A Kotlin `if` is an expression and is commonly used to
+                 * initialize a configurable Navigation start destination.
+                 * Preserve its value branches as UAST data so downstream
+                 * analysis can prove a finite result set without parsing the
+                 * Kotlin source string retained for diagnostics.
+                 */
+                result.put(
+                    "conditionExpression",
+                    expressionData(conditional.getCondition())
+                );
+                result.put(
+                    "thenExpression",
+                    expressionData(conditional.getThenExpression())
+                );
+                UExpression elseExpression = conditional.getElseExpression();
+                if (
+                    elseExpression != null &&
+                    !(elseExpression instanceof UastEmptyExpression)
+                ) {
+                    result.put(
+                        "elseExpression",
+                        expressionData(elseExpression)
+                    );
+                }
+            } else if (expression instanceof UBlockExpression block) {
+                List<UExpression> expressions = block.getExpressions();
+                if (!expressions.isEmpty()) {
+                    UExpression terminal = expressions.get(
+                        expressions.size() - 1
+                    );
+                    if (!(terminal instanceof UastEmptyExpression)) {
+                        result.put(
+                            "terminalExpression",
+                            expressionData(terminal)
+                        );
+                    }
+                }
+            }
+            if (
+                expression
+                    instanceof UQualifiedReferenceExpression qualified
+            ) {
+                /*
+                 * Preserve the semantic receiver/selector split. Consumers
+                 * can then recognize that `Screen.Home.route` and
+                 * `Screen.Home.name` refer to the same route-owning object
+                 * without parsing Kotlin source text or knowing either
+                 * property name.
+                 */
+                result.put(
+                    "receiverExpression",
+                    expressionData(qualified.getReceiver())
+                );
+                result.put(
+                    "selectorExpression",
+                    expressionData(qualified.getSelector())
+                );
+            }
+            if (expression instanceof ULambdaExpression lambda) {
+                result.put("callableRef", lambdaDeclarationRef(lambda));
+            } else if (
+                expression
+                    instanceof UCallableReferenceExpression callableReference
+            ) {
+                PsiElement target = callableReference.resolve();
+                result.put(
+                    "callableReferenceRef",
+                    callableReferenceRef(callableReference, target)
+                );
+                if (target != null) {
+                    result.put("resolvedSymbol", symbolData(target));
+                }
+            } else if (
+                expression instanceof UObjectLiteralExpression objectLiteral
+            ) {
+                result.put(
+                    "classRef",
+                    classDeclarationRef(objectLiteral.getDeclaration())
+                );
+            } else if (
+                expression instanceof UClassLiteralExpression classLiteral
+            ) {
+                result.put(
+                    "classLiteral",
+                    classLiteralData(classLiteral)
+                );
+            } else if (expression instanceof UCallExpression call) {
+                result.put("callRef", callRef(call));
+            }
+            if (!result.containsKey("callRef")) {
+                UCallExpression nestedCall = findCallExpression(expression);
+                if (nestedCall != null) {
+                    result.put("callRef", callRef(nestedCall));
+                }
+            }
+            UClassLiteralExpression nestedClassLiteral =
+                findClassLiteral(expression);
+            if (
+                nestedClassLiteral != null &&
+                !(expression instanceof UClassLiteralExpression)
+            ) {
+                result.put(
+                    "classLiteral",
+                    classLiteralData(nestedClassLiteral)
+                );
+            }
+
+            PsiElement resolved = resolveExpression(expression);
+            if (resolved != null) {
+                result.put("resolvedSymbol", symbolData(resolved));
+                Map<String, Object> resource = resourceReference(resolved);
+                if (resource != null) {
+                    result.put("resourceReference", resource);
+                }
+            }
+            Object constant = evaluatedConstant(expression);
+            if (constant != null || expression instanceof ULiteralExpression) {
+                result.put("constantValue", constant);
+            } else {
+                putStringComposition(result, expression);
+            }
+            return result;
+        }
+
+        /**
+         * Retains the operand structure of a non-constant String composition.
+         * Kotlin string templates and Java String {@code +} expressions both
+         * arrive as {@link UPolyadicExpression}, so downstream consumers can
+         * fold constant operands and preserve runtime operands without parsing
+         * either language's source syntax. The field is optional, keeping raw
+         * protocol v1 readers and older analyzer output compatible.
+         */
+        private void putStringComposition(
+            Map<String, Object> result,
+            UExpression expression
+        ) {
+            if (
+                !(expression instanceof UPolyadicExpression composition) ||
+                composition.getOperator() != UastBinaryOperator.PLUS ||
+                !isStringType(expression.getExpressionType())
+            ) {
+                return;
+            }
+            List<Object> operands = new ArrayList<>();
+            for (UExpression operand : composition.getOperands()) {
+                operands.add(expressionData(operand));
+            }
+            if (operands.isEmpty()) {
+                return;
+            }
+            result.put(
+                "stringComposition",
+                RawJson.object(
+                    "operator", "+",
+                    "operands", operands
+                )
+            );
+        }
+
+        private boolean isStringType(@Nullable PsiType type) {
+            String name = typeName(type);
+            return "java.lang.String".equals(name) ||
+                "kotlin.String".equals(name);
+        }
+
+        private Map<String, Object> classLiteralData(
+            UClassLiteralExpression expression
+        ) {
+            PsiType type = expression.getType();
+            UExpression literalExpression = expression.getExpression();
+            Map<String, Object> result = RawJson.object(
+                "type", typeName(type),
+                "expression", sourceOrEmpty(literalExpression),
+                "expressionType",
+                    literalExpression == null
+                        ? ""
+                        : typeName(literalExpression.getExpressionType())
+            );
+            PsiElement resolved = literalExpression == null
+                ? null
+                : resolveExpression(literalExpression);
+            if (resolved instanceof PsiClass declaration) {
+                result.put(
+                    "resolvedClassQualifiedName",
+                    valueOrEmpty(declaration.getQualifiedName())
+                );
+            } else {
+                String typeName = typeName(type);
+                if (!typeName.isEmpty()) {
+                    result.put("resolvedClassQualifiedName", typeName);
+                }
+            }
+            return result;
+        }
+
+        @Nullable
+        private UClassLiteralExpression findClassLiteral(
+            UExpression expression
+        ) {
+            if (expression instanceof UClassLiteralExpression classLiteral) {
+                return classLiteral;
+            }
+            if (
+                expression
+                    instanceof UQualifiedReferenceExpression qualified
+            ) {
+                UClassLiteralExpression receiver = findClassLiteral(
+                    qualified.getReceiver()
+                );
+                return receiver != null
+                    ? receiver
+                    : findClassLiteral(qualified.getSelector());
+            }
+            return null;
+        }
+
+        @Nullable
+        private UCallExpression findCallExpression(
+            UExpression expression
+        ) {
+            if (expression instanceof UCallExpression call) {
+                return call;
+            }
+            if (
+                expression
+                    instanceof UQualifiedReferenceExpression qualified
+            ) {
+                UCallExpression selector = findCallExpression(
+                    qualified.getSelector()
+                );
+                return selector != null
+                    ? selector
+                    : findCallExpression(qualified.getReceiver());
+            }
+            return null;
+        }
+
+        @Nullable
+        private Object evaluatedConstant(UExpression expression) {
+            Object value;
+            try {
+                value = expression.evaluate();
+            } catch (RuntimeException ignored) {
+                return null;
+            }
+            if (RawJson.isNonFiniteNumber(value)) {
+                return null;
+            }
+            if (
+                value == null ||
+                value instanceof String ||
+                value instanceof Number ||
+                value instanceof Boolean
+            ) {
+                return value;
+            }
+            if (value instanceof Character character) {
+                return character.toString();
+            }
+            return null;
+        }
+
+        @Nullable
+        private PsiElement resolveExpression(UExpression expression) {
+            if (expression instanceof UResolvable resolvable) {
+                try {
+                    return resolvable.resolve();
+                } catch (RuntimeException ignored) {
+                    return null;
+                }
+            }
+            return null;
+        }
+
+        private Map<String, Object> symbolData(PsiElement symbol) {
+            Map<String, Object> result = RawJson.object(
+                "kind", symbolKind(symbol)
+            );
+            if (symbol instanceof PsiMethod method) {
+                result.put("name", method.getName());
+                result.put("signature", methodSignature(method));
+                PsiClass owner = method.getContainingClass();
+                result.put(
+                    "ownerQualifiedName",
+                    owner == null
+                        ? ""
+                        : valueOrEmpty(owner.getQualifiedName())
+                );
+                KtProperty kotlinProperty = kotlinProperty(method);
+                if (
+                    kotlinProperty != null &&
+                    method.getParameterList().getParametersCount() == 0
+                ) {
+                    putKotlinPropertyInitializer(
+                        result,
+                        kotlinProperty
+                    );
+                }
+            } else if (symbol instanceof PsiClass declaration) {
+                result.put("name", valueOrEmpty(declaration.getName()));
+                result.put(
+                    "qualifiedName",
+                    valueOrEmpty(declaration.getQualifiedName())
+                );
+            } else if (symbol instanceof PsiVariable variable) {
+                result.put("name", valueOrEmpty(variable.getName()));
+                result.put("type", typeName(variable.getType()));
+                result.put(
+                    "declarationRef",
+                    variableDeclarationRef(variable)
+                );
+                PsiElement declaration = variable.getNavigationElement();
+                String declarationSource = sourceDeclarationText(
+                    declaration == null ? variable : declaration
+                );
+                String variableSource = sourceDeclarationText(variable);
+                if (variableSource.length() > declarationSource.length()) {
+                    declarationSource = variableSource;
+                }
+                if (!declarationSource.isBlank()) {
+                    result.put("declarationSource", declarationSource);
+                }
+                PsiElement initializer = variable.getInitializer();
+                KtProperty kotlinProperty = kotlinProperty(variable);
+                if (initializer == null && kotlinProperty != null) {
+                    KtProperty property = kotlinProperty;
+                    KtExpression delegate = property.getDelegateExpression();
+                    if (delegate != null) {
+                        initializer = delegate;
+                        result.put("initializerKind", "delegate");
+                    } else if (property.getInitializer() != null) {
+                        initializer = property.getInitializer();
+                    }
+                }
+                String initializerSource = sourceDeclarationText(initializer);
+                if (!initializerSource.isBlank()) {
+                    result.put("initializerSource", initializerSource);
+                }
+                UExpression initializerExpression =
+                    variableInitializerExpression(variable, initializer);
+                if (initializerExpression != null) {
+                    result.put(
+                        "initializer",
+                        expressionData(initializerExpression)
+                    );
+                }
+                if (variable instanceof PsiField field) {
+                    PsiClass owner = field.getContainingClass();
+                    result.put(
+                        "ownerQualifiedName",
+                        owner == null
+                            ? ""
+                            : valueOrEmpty(owner.getQualifiedName())
+                    );
+                }
+            } else if (symbol instanceof PsiNamedElement named) {
+                result.put("name", valueOrEmpty(named.getName()));
+            }
+            return result;
+        }
+
+        @Nullable
+        private UExpression variableInitializerExpression(
+            PsiVariable variable,
+            @Nullable PsiElement initializer
+        ) {
+            /*
+             * Kotlin local variables commonly resolve to a light
+             * PsiVariable. Its Psi initializer has source text, but cannot
+             * always be converted directly to UExpression. Convert the
+             * navigation declaration to UVariable first so the protocol
+             * retains the structured initializer (and its callRef).
+            */
+            PsiElement navigation = variable.getNavigationElement();
+            KtProperty kotlinProperty = kotlinProperty(variable);
+            if (kotlinProperty != null) {
+                KtProperty property = kotlinProperty;
+                /*
+                 * A Kotlin delegated local (`var value by remember { ... }`)
+                 * has no ordinary PsiVariable initializer. The delegate is,
+                 * however, a first-class Kotlin PSI expression. Convert that
+                 * expression through UAST so consumers receive the same
+                 * structured callRef as for an `=` initializer; never parse
+                 * declaration text to recover it.
+                 */
+                KtExpression delegatedOrInitialized =
+                    property.getDelegateExpressionOrInitializer();
+                UExpression expression = delegatedOrInitialized == null
+                    ? null
+                    : UastContextKt.toUElement(
+                        delegatedOrInitialized,
+                        UExpression.class
+                    );
+                if (expression != null) {
+                    return expression;
+                }
+            }
+            UVariable declaration = variable instanceof UVariable uVariable
+                ? uVariable
+                : UastContextKt.toUElement(
+                    navigation,
+                    UVariable.class
+                );
+            if (
+                declaration != null &&
+                declaration.getUastInitializer() != null
+            ) {
+                return declaration.getUastInitializer();
+            }
+            return initializer == null
+                ? null
+                : UastContextKt.toUElement(
+                    initializer,
+                    UExpression.class
+                );
+        }
+
+        private String variableDeclarationRef(PsiVariable variable) {
+            PsiElement declaration = variable.getNavigationElement();
+            PsiElement anchor = declaration == null ? variable : declaration;
+            return variableDeclarationRefs.computeIfAbsent(
+                anchor,
+                ignored -> writer.stableId(
+                    "variable-declaration",
+                    RawLocation.from(context, context.getLocation(anchor)),
+                    valueOrEmpty(variable.getName()) + ":" +
+                        typeName(variable.getType())
+                )
+            );
+        }
+
+        @Nullable
+        private KtProperty kotlinProperty(PsiElement element) {
+            List<PsiElement> pending = new ArrayList<>();
+            pending.add(element);
+            pending.add(element.getNavigationElement());
+            pending.add(element.getOriginalElement());
+            Set<PsiElement> visited = java.util.Collections.newSetFromMap(
+                new IdentityHashMap<>()
+            );
+            for (int index = 0;
+                index < pending.size() && index < 32;
+                index += 1) {
+                PsiElement candidate = pending.get(index);
+                if (candidate == null || !visited.add(candidate)) {
+                    continue;
+                }
+                if (candidate instanceof KtProperty property) {
+                    return property;
+                }
+                if (candidate instanceof KtLightElement<?, ?> light) {
+                    PsiElement origin = light.getKotlinOrigin();
+                    if (origin instanceof KtProperty property) {
+                        return property;
+                    }
+                    if (origin != null) {
+                        pending.add(origin);
+                    }
+                }
+                PsiElement parent = candidate.getParent();
+                if (parent != null) {
+                    pending.add(parent);
+                }
+            }
+            return null;
+        }
+
+        private void putKotlinPropertyInitializer(
+            Map<String, Object> result,
+            KtProperty property
+        ) {
+            String declarationSource = sourceDeclarationText(property);
+            if (!declarationSource.isBlank()) {
+                result.put("declarationSource", declarationSource);
+            }
+            KtExpression initializer =
+                property.getDelegateExpressionOrInitializer();
+            if (initializer == null) {
+                return;
+            }
+            if (property.getDelegateExpression() != null) {
+                result.put("initializerKind", "delegate");
+            }
+            String initializerSource = sourceDeclarationText(initializer);
+            if (!initializerSource.isBlank()) {
+                result.put("initializerSource", initializerSource);
+            }
+            UExpression initializerExpression = UastContextKt.toUElement(
+                initializer,
+                UExpression.class
+            );
+            if (initializerExpression != null) {
+                result.put(
+                    "initializer",
+                    expressionData(initializerExpression)
+                );
+            }
+        }
+
+        private String sourceDeclarationText(
+            @Nullable PsiElement element
+        ) {
+            if (
+                element == null ||
+                element.getContainingFile() instanceof PsiCompiledFile
+            ) {
+                return "";
+            }
+            try {
+                return valueOrEmpty(element.getText());
+            } catch (AssertionError | RuntimeException ignored) {
+                return "";
+            }
+        }
+
+        @Nullable
+        private Map<String, Object> resourceReference(PsiElement symbol) {
+            if (!(symbol instanceof PsiField field)) {
+                return null;
+            }
+            PsiClass typeClass = field.getContainingClass();
+            PsiClass rClass = typeClass == null
+                ? null
+                : typeClass.getContainingClass();
+            if (
+                typeClass == null ||
+                rClass == null ||
+                !"R".equals(rClass.getName())
+            ) {
+                return null;
+            }
+            return RawJson.object(
+                "resourceType", valueOrEmpty(typeClass.getName()),
+                "resourceName", valueOrEmpty(field.getName()),
+                "rClassQualifiedName",
+                    valueOrEmpty(rClass.getQualifiedName())
+            );
+        }
+
+        private String callRef(UCallExpression call) {
+            PsiMethod target = call.resolve();
+            return writer.stableId(
+                target == null ? "unresolved-call" : "resolved-call",
+                location(call),
+                callDiscriminator(call, target)
+            );
+        }
+
+        private String lambdaDeclarationRef(ULambdaExpression lambda) {
+            return writer.stableId(
+                "lambda-declaration",
+                location(lambda),
+                lambdaDiscriminator(lambda)
+            );
+        }
+
+        private String callableReferenceRef(
+            UCallableReferenceExpression reference,
+            @Nullable PsiElement target
+        ) {
+            return writer.stableId(
+                "callable-reference",
+                location(reference),
+                callableReferenceDiscriminator(reference, target)
+            );
+        }
+
+        private String classDeclarationRef(UClass declaration) {
+            return writer.stableId(
+                "class-declaration",
+                location(declaration),
+                classDiscriminator(declaration)
+            );
+        }
+
+        private String methodDeclarationRef(UMethod method) {
+            return writer.stableId(
+                "method-declaration",
+                location(method),
+                methodSignature(method)
+            );
+        }
+
+        private void putCallableScope(
+            Map<String, Object> data,
+            UElement element
+        ) {
+            String callable = enclosingCallableRef(element);
+            if (!callable.isEmpty()) {
+                data.put("enclosingCallableRef", callable);
+            }
+        }
+
+        private String enclosingCallableRef(UElement element) {
+            UElement current = element.getUastParent();
+            while (current != null && !(current instanceof UFile)) {
+                if (current instanceof ULambdaExpression lambda) {
+                    return lambdaDeclarationRef(lambda);
+                }
+                if (current instanceof UMethod method) {
+                    return methodDeclarationRef(method);
+                }
+                current = current.getUastParent();
+            }
+            return "";
+        }
+
+        private String callDiscriminator(
+            UCallExpression call,
+            @Nullable PsiMethod target
+        ) {
+            return (
+                target == null
+                    ? valueOrEmpty(call.getMethodName())
+                    : methodSignature(target)
+            ) + ":" + call.asSourceString();
+        }
+
+        private String lambdaDiscriminator(ULambdaExpression lambda) {
+            return enclosingMethodSignature(lambda)
+                + ":"
+                + lambda.asSourceString();
+        }
+
+        private String callableReferenceDiscriminator(
+            UCallableReferenceExpression reference,
+            @Nullable PsiElement target
+        ) {
+            String targetIdentity = target instanceof PsiMethod method
+                ? methodSignature(method)
+                : target instanceof PsiNamedElement named
+                    ? valueOrEmpty(named.getName())
+                    : "";
+            return targetIdentity + ":" + reference.asSourceString();
+        }
+
+        private PsiParameter mappedParameter(
+            UCallExpression call,
+            UExpression argument,
+            Map<UExpression, PsiParameter> mapping,
+            PsiParameter[] parameters
+        ) {
+            PsiParameter direct = mapping.get(argument);
+            if (direct != null) {
+                return direct;
+            }
+            for (Map.Entry<UExpression, PsiParameter> entry
+                : mapping.entrySet()) {
+                if (sameSource(argument, entry.getKey())) {
+                    return entry.getValue();
+                }
+            }
+            for (int index = 0; index < parameters.length; index += 1) {
+                UExpression mappedArgument = call.getArgumentForParameter(index);
+                if (mappedArgument != null
+                    && sameSource(argument, mappedArgument)) {
+                    return parameters[index];
+                }
+            }
+            return null;
+        }
+
+        private void emitCondition(
+            UElement node,
+            @Nullable UExpression expression,
+            String conditionKind,
+            String source
+        ) {
+            RawLocation location = location(node);
+            Map<String, Object> data = RawJson.object(
+                "language", sourceLanguage(context),
+                "conditionKind", conditionKind,
+                "expression", source,
+                "expressionType",
+                    expression == null
+                        ? ""
+                        : typeName(expression.getExpressionType()),
+                "enclosingClass", enclosingClassName(node),
+                "enclosingMethod", enclosingMethodSignature(node)
+            );
+            if (expression != null) {
+                data.put(
+                    "expressionStructure",
+                    conditionExpressionData(expression)
+                );
+            }
+            putCallableScope(data, node);
+            writer.emit(
+                "condition",
+                location,
+                conditionKind + ":" + source,
+                data
+            );
+        }
+
+        private Map<String, Object> conditionExpressionData(
+            UExpression expression
+        ) {
+            Map<String, Object> result = expressionData(expression);
+            if (expression instanceof UBinaryExpression binary) {
+                result.put("operator", binary.getOperator().getText());
+                result.put(
+                    "left",
+                    conditionExpressionData(binary.getLeftOperand())
+                );
+                result.put(
+                    "right",
+                    conditionExpressionData(binary.getRightOperand())
+                );
+            }
+            return result;
+        }
+
+        private List<Object> enclosingConditionRefs(UElement node) {
+            Set<String> refs = new LinkedHashSet<>();
+            for (Object rawContext : enclosingConditionContexts(node)) {
+                if (!(rawContext instanceof Map<?, ?> context)) {
+                    continue;
+                }
+                Object conditionRef = context.get("conditionRef");
+                if (conditionRef instanceof String ref && !ref.isBlank()) {
+                    refs.add(ref);
+                }
+            }
+            return new ArrayList<>(refs);
+        }
+
+        private List<Object> enclosingConditionContexts(UElement node) {
+            Map<String, Object> contexts = new java.util.LinkedHashMap<>();
+            UElement current = node.getUastParent();
+            while (current != null && !(current instanceof UFile)) {
+                if (current instanceof UIfExpression condition) {
+                    String ref = conditionRef(condition);
+                    if (isWithin(node, condition.getThenExpression())) {
+                        contexts.put(
+                            ref,
+                            conditionContext(
+                                ref,
+                                "then",
+                                "true",
+                                ""
+                            )
+                        );
+                    } else if (
+                        isWithin(node, condition.getElseExpression())
+                    ) {
+                        contexts.put(
+                            ref,
+                            conditionContext(
+                                ref,
+                                "else",
+                                "false",
+                                ""
+                            )
+                        );
+                    }
+                } else if (current instanceof USwitchExpression condition) {
+                    USwitchClauseExpression clause = enclosingSwitchClause(
+                        node,
+                        condition
+                    );
+                    if (clause != null) {
+                        String ref = conditionRef(condition);
+                        List<Object> cases = new ArrayList<>();
+                        List<Object> caseStructures = new ArrayList<>();
+                        for (UExpression value : clause.getCaseValues()) {
+                            cases.add(value.asSourceString());
+                            caseStructures.add(
+                                conditionExpressionData(value)
+                            );
+                        }
+                        contexts.put(
+                            ref,
+                            RawJson.object(
+                                "conditionRef", ref,
+                                "branchKind", "case",
+                                "polarity", "case",
+                                "caseValues", cases,
+                                "caseValueStructures", caseStructures
+                            )
+                        );
+                    }
+                }
+                if (current instanceof UBlockExpression block) {
+                    addTerminatingFallthroughContexts(
+                        node,
+                        block,
+                        contexts
+                    );
+                }
+                current = current.getUastParent();
+            }
+            return new ArrayList<>(contexts.values());
+        }
+
+        private void addTerminatingFallthroughContexts(
+            UElement node,
+            UBlockExpression block,
+            Map<String, Object> contexts
+        ) {
+            List<UExpression> expressions = block.getExpressions();
+            int containingIndex = -1;
+            for (int index = 0; index < expressions.size(); index += 1) {
+                if (isWithin(node, expressions.get(index))) {
+                    containingIndex = index;
+                    break;
+                }
+            }
+            if (containingIndex < 0) {
+                return;
+            }
+            for (int index = 0; index < containingIndex; index += 1) {
+                UExpression expression = expressions.get(index);
+                if (!(expression instanceof UIfExpression condition)) {
+                    continue;
+                }
+                if (
+                    hasElseExpression(condition) ||
+                    !definitelyTerminates(condition.getThenExpression())
+                ) {
+                    continue;
+                }
+                String ref = conditionRef(condition);
+                contexts.put(
+                    ref,
+                    conditionContext(
+                        ref,
+                        "fallthrough",
+                        "false",
+                        "then-terminates"
+                    )
+                );
+            }
+        }
+
+        private boolean definitelyTerminates(
+            @Nullable UExpression expression
+        ) {
+            if (
+                expression instanceof UReturnExpression ||
+                expression instanceof UThrowExpression
+            ) {
+                return true;
+            }
+            if (expression instanceof UBlockExpression block) {
+                List<UExpression> expressions = block.getExpressions();
+                return !expressions.isEmpty() &&
+                    definitelyTerminates(
+                        expressions.get(expressions.size() - 1)
+                    );
+            }
+            if (expression instanceof UIfExpression condition) {
+                return hasElseExpression(condition) &&
+                    definitelyTerminates(condition.getThenExpression()) &&
+                    definitelyTerminates(condition.getElseExpression());
+            }
+            return false;
+        }
+
+        private boolean hasElseExpression(UIfExpression condition) {
+            UExpression expression = condition.getElseExpression();
+            return expression != null &&
+                !(expression instanceof UastEmptyExpression);
+        }
+
+        private Map<String, Object> conditionContext(
+            String conditionRef,
+            String branchKind,
+            String polarity,
+            String termination
+        ) {
+            Map<String, Object> result = RawJson.object(
+                "conditionRef", conditionRef,
+                "branchKind", branchKind,
+                "polarity", polarity
+            );
+            if (!termination.isBlank()) {
+                result.put("termination", termination);
+            }
+            return result;
+        }
+
+        private String conditionRef(UIfExpression condition) {
+            return writer.stableId(
+                "condition",
+                location(condition),
+                "if:" + condition.getCondition().asSourceString()
+            );
+        }
+
+        private String conditionRef(USwitchExpression condition) {
+            UExpression subject = condition.getExpression();
+            String source = subject == null
+                ? condition.asSourceString()
+                : subject.asSourceString();
+            return writer.stableId(
+                "condition",
+                location(condition),
+                "switch-or-when:" + source
+            );
+        }
+
+        @Nullable
+        private USwitchClauseExpression enclosingSwitchClause(
+            UElement node,
+            USwitchExpression condition
+        ) {
+            UElement current = node;
+            while (current != null && current != condition) {
+                if (current instanceof USwitchClauseExpression clause) {
+                    return clause;
+                }
+                current = current.getUastParent();
+            }
+            return null;
+        }
+
+        private boolean isWithin(
+            UElement node,
+            @Nullable UElement ancestor
+        ) {
+            if (ancestor == null) {
+                return false;
+            }
+            UElement current = node;
+            while (current != null) {
+                if (current == ancestor) {
+                    return true;
+                }
+                current = current.getUastParent();
+            }
+            // Some Java/Kotlin UAST implementations materialize equivalent
+            // wrapper instances when block expressions are queried. Fall
+            // back to the Lint source range so sibling control-flow analysis
+            // does not depend on wrapper object identity.
+            RawLocation inner = location(node);
+            RawLocation outer = location(ancestor);
+            return inner.startOffset() >= 0 &&
+                inner.endOffset() >= inner.startOffset() &&
+                outer.startOffset() >= 0 &&
+                outer.endOffset() >= outer.startOffset() &&
+                outer.startOffset() <= inner.startOffset() &&
+                outer.endOffset() >= inner.endOffset();
+        }
+
+        private RawLocation location(UElement element) {
+            return RawLocation.from(
+                context,
+                context.getLocation(element)
+            );
+        }
+
+        @Nullable
+        private UClass enclosingClassDeclaration(UElement element) {
+            UElement current = element.getUastParent();
+            while (current != null && !(current instanceof UFile)) {
+                if (current instanceof UClass declaration) {
+                    return declaration;
+                }
+                current = current.getUastParent();
+            }
+            return null;
+        }
+    }
+
+    private static int parameterIndex(
+        PsiParameter[] parameters,
+        @Nullable PsiParameter parameter
+    ) {
+        if (parameter == null) {
+            return -1;
+        }
+        for (int index = 0; index < parameters.length; index += 1) {
+            if (parameters[index] == parameter
+                || parameters[index].isEquivalentTo(parameter)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+
+    private static boolean sameSource(
+        UExpression left,
+        UExpression right
+    ) {
+        if (left == right) {
+            return true;
+        }
+        PsiElement leftSource = left.getSourcePsi();
+        PsiElement rightSource = right.getSourcePsi();
+        if (leftSource != null && rightSource != null) {
+            return leftSource.isEquivalentTo(rightSource);
+        }
+        return left.asSourceString().equals(right.asSourceString());
+    }
+
+    private static boolean containsLambda(UExpression expression) {
+        if (expression instanceof ULambdaExpression) {
+            return true;
+        }
+        if (expression instanceof UNamedExpression namedExpression) {
+            return containsLambda(namedExpression.getExpression());
+        }
+        return false;
+    }
+
+    private static String expressionKind(UExpression expression) {
+        if (expression instanceof ULambdaExpression) {
+            return "lambda";
+        }
+        if (expression instanceof UCallableReferenceExpression) {
+            return "callable-reference";
+        }
+        if (expression instanceof UObjectLiteralExpression) {
+            return "object-literal";
+        }
+        if (expression instanceof UClassLiteralExpression) {
+            return "class-literal";
+        }
+        if (expression instanceof UCallExpression) {
+            return "call";
+        }
+        if (expression instanceof ULiteralExpression) {
+            return "literal";
+        }
+        if (expression instanceof UResolvable) {
+            return "reference";
+        }
+        return "expression";
+    }
+
+    private static String symbolKind(PsiElement symbol) {
+        if (symbol instanceof PsiMethod) {
+            return "method";
+        }
+        if (symbol instanceof PsiClass) {
+            return "class";
+        }
+        if (symbol instanceof PsiField) {
+            return "field";
+        }
+        if (symbol instanceof PsiParameter) {
+            return "parameter";
+        }
+        if (symbol instanceof PsiVariable) {
+            return "variable";
+        }
+        if (symbol instanceof PsiNamedElement) {
+            return "named-element";
+        }
+        return "psi-element";
+    }
+
+    private static List<Object> annotationNames(UAnnotated declaration) {
+        List<Object> result = new ArrayList<>();
+        declaration.getUAnnotations().forEach(annotation -> {
+            String qualifiedName = annotation.getQualifiedName();
+            if (qualifiedName != null && !qualifiedName.isBlank()) {
+                result.add(qualifiedName);
+            }
+        });
+        result.sort((left, right) ->
+            String.valueOf(left).compareTo(String.valueOf(right))
+        );
+        return result;
+    }
+
+    private static boolean isComposable(UAnnotated declaration) {
+        return declaration.getUAnnotations().stream().anyMatch(annotation ->
+            "androidx.compose.runtime.Composable".equals(
+                annotation.getQualifiedName()
+            )
+        );
+    }
+
+    private static boolean isAssignmentOperator(String operator) {
+        return "=".equals(operator)
+            || "+=".equals(operator)
+            || "-=".equals(operator)
+            || "*=".equals(operator)
+            || "/=".equals(operator)
+            || "%=".equals(operator)
+            || "&=".equals(operator)
+            || "|=".equals(operator)
+            || "^=".equals(operator)
+            || "<<=".equals(operator)
+            || ">>=".equals(operator)
+            || ">>>=".equals(operator);
+    }
+
+    private static String classDiscriminator(UClass declaration) {
+        return valueOrEmpty(declaration.getQualifiedName())
+            + ":"
+            + valueOrEmpty(declaration.getName());
+    }
+
+    private static String classKind(UClass declaration) {
+        if (declaration.getName() == null) {
+            return "anonymous-class";
+        }
+        if (declaration.isAnnotationType()) {
+            return "annotation";
+        }
+        if (declaration.isEnum()) {
+            return "enum";
+        }
+        if (declaration.isInterface()) {
+            return "interface";
+        }
+        return "class";
+    }
+
+    private static String sourceLanguage(Context context) {
+        String name = context.file.getName();
+        if (name.endsWith(".kt")) {
+            return "kotlin";
+        }
+        if (name.endsWith(".java")) {
+            return "java";
+        }
+        if (name.endsWith(".xml")) {
+            return "xml";
+        }
+        return "unknown";
+    }
+
+    private static String methodSignature(PsiMethod method) {
+        PsiClass owner = method.getContainingClass();
+        String ownerName = owner == null
+            ? ""
+            : valueOrEmpty(owner.getQualifiedName());
+        StringBuilder result = new StringBuilder(ownerName)
+            .append('#')
+            .append(method.getName())
+            .append('(');
+        PsiParameter[] parameters =
+            method.getParameterList().getParameters();
+        for (int index = 0; index < parameters.length; index += 1) {
+            if (index > 0) {
+                result.append(',');
+            }
+            result.append(typeName(parameters[index].getType()));
+        }
+        return result.append(')').toString();
+    }
+
+    private static String enclosingClassName(UElement element) {
+        UElement current = element.getUastParent();
+        while (current != null) {
+            if (current instanceof UClass declaration) {
+                return valueOrEmpty(declaration.getQualifiedName());
+            }
+            current = current.getUastParent();
+        }
+        return "";
+    }
+
+    private static String enclosingMethodSignature(UElement element) {
+        UElement current = element.getUastParent();
+        while (current != null) {
+            if (current instanceof UMethod method) {
+                return methodSignature(method);
+            }
+            current = current.getUastParent();
+        }
+        return "";
+    }
+
+    private static String typeName(@Nullable PsiType type) {
+        return type == null ? "" : type.getCanonicalText();
+    }
+
+    private static String resourceFolder(XmlContext context) {
+        ResourceFolderType type = context.getResourceFolderType();
+        return type == null ? "" : type.getName();
+    }
+
+    private static String valueOrEmpty(@Nullable String value) {
+        return value == null ? "" : value;
+    }
+
+    private static String sourceOrEmpty(@Nullable UElement element) {
+        return element == null ? "" : element.asSourceString();
+    }
+}