Use free-variable collection for sibling binding detection

collectIdentifiers was too broad — it included member property names
like `color` from `theme.color.bgFocus`, causing false positives when
a destructured sibling shared that name. Replace with collectFreeIdentifiers
which skips non-computed property names in member expressions, collecting
only actual variable references (roots of expression chains).

Co-authored-by: Kenneth Skovhus <skovhus@users.noreply.github.com>

Author: cursoragent

src/__tests__/transform.test.ts

@@ -3759,6 +3759,58 @@ export const App = () => <Box enabled>Test</Box>;
     expect(result.code).toBeNull();
   });
 
+  it("should bail when both theme boolean branches are unresolvable", () => {
+    // When resolveValueOptional returns undefined for both branches of a
+    // theme.isDark ternary, the codemod must bail rather than fall through
+    // to generic handlers that would emit the arrow function as a string.
+    const source = `
+import styled from "styled-components";
+
+const Box = styled.div\`
+  color: \${(p) =>
+    p.theme.isDark ? p.theme.baseTheme?.color.bgSub : p.theme.baseTheme?.color.bgBase};
+\`;
+
+export const App = () => <Box>Test</Box>;
+`;
+
+    const result = transformWithWarnings(
+      { source, path: "theme-both-unresolved.tsx" },
+      { jscodeshift: j, j, stats: () => {}, report: () => {} },
+      { adapter: fixtureAdapter },
+    );
+
+    expect(result.code).toBeNull();
+  });
+
+  it("should not reject sibling binding when name collides with theme property path segment", () => {
+    // collectIdentifiers picks up member property names like `color` from
+    // `theme.color.bgFocus`. A destructured sibling named `color` must not
+    // cause a false positive rejection — only actual free variable references
+    // should be checked.
+    const source = `
+import styled from "styled-components";
+
+const Box = styled.div\`
+  background-color: \${({ theme, color }) =>
+    theme.isDark ? theme.baseTheme?.color.bgSub : theme.color.bgFocus};
+\`;
+
+export const App = () => <Box color="red">Test</Box>;
+`;
+
+    const result = transformWithWarnings(
+      { source, path: "theme-color-sibling.tsx" },
+      { jscodeshift: j, j, stats: () => {}, report: () => {} },
+      { adapter: fixtureAdapter },
+    );
+
+    // The `color` destructured param is never referenced in the expression
+    // (only theme.color is used), so the transform should succeed
+    expect(result.code).not.toBeNull();
+    expect(result.code).toContain("useTheme");
+  });
+
   it("should bail on theme access inside pseudo/media context (module-scoped style fn)", () => {
     // Theme-rewritten expressions can't be placed in module-scoped stylex.create functions.
     // The `theme` variable from useTheme() is only available in the wrapper component body.

src/internal/builtin-handlers/conditionals.ts

@@ -7,7 +7,6 @@ import {
   type ArrowFnParamBindings,
   type CallExpressionNode,
   cloneAstNode,
-  collectIdentifiers,
   getArrowFnParamBindings,
   getArrowFnSingleParamName,
   getFunctionBodyExpr,
@@ -1678,7 +1677,7 @@ function isFullyTransformedThemeExpr(
   info: ThemeParamInfo | null,
 ): boolean {
   const ids = new Set<string>();
-  collectIdentifiers(transformed, ids);
+  collectFreeIdentifiers(transformed, ids);
   if (paramName && ids.has(paramName)) {
     return false;
   }
@@ -1696,6 +1695,50 @@ function isFullyTransformedThemeExpr(
   return true;
 }
 
+/**
+ * Collects free variable identifiers from an AST node, excluding
+ * non-computed property names in member expressions (e.g., in
+ * `theme.color.bgSub`, only `theme` is a free variable; `color`
+ * and `bgSub` are property accesses, not variable references).
+ */
+function collectFreeIdentifiers(node: unknown, out: Set<string>): void {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      collectFreeIdentifiers(child, out);
+    }
+    return;
+  }
+  const typed = node as Record<string, unknown>;
+  const nodeType = typed.type as string | undefined;
+
+  // For member expressions, only recurse into the object (left side).
+  // Skip the property name unless it's computed (bracket notation).
+  if (nodeType === "MemberExpression" || nodeType === "OptionalMemberExpression") {
+    collectFreeIdentifiers(typed.object, out);
+    if (typed.computed) {
+      collectFreeIdentifiers(typed.property, out);
+    }
+    return;
+  }
+
+  if (nodeType === "Identifier" && typeof typed.name === "string") {
+    out.add(typed.name);
+  }
+
+  for (const key of Object.keys(typed)) {
+    if (key === "loc" || key === "comments" || key === "type") {
+      continue;
+    }
+    const child = typed[key];
+    if (child && typeof child === "object") {
+      collectFreeIdentifiers(child, out);
+    }
+  }
+}
+
 /**
  * Deep-clones an expression and replaces `<paramName>.theme.*` or `theme.*`
  * (for destructured theme binding) with `theme.*` references suitable for