jsx_rosetta 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ae2ca5d2ff613e264c7a6027c5a95c57781916a38b52090d6c9d62ba7cafd8c
-  data.tar.gz: 3e6a2e6f2a54e1dd01002e3e1312d3c1144e3af7e315c55cb3eeee137b858c79
+  metadata.gz: 57170a56efc4593faf87b9ee0e3ac055f862cb058b9185ed57bb9a12d47f9af4
+  data.tar.gz: bd52ab90f51bc6be003f33b7cc10cda266002fa55386bc079f199fbcc9f3130b
 SHA512:
-  metadata.gz: 11b3d8dea5bb887a1b55ebccc0119ce5703bf2c39251a0144dda973d01dd05f7e9b58337fb383e87f3c66d1dfac9a465e6cc5a14dca827e0612073401e4f908c
-  data.tar.gz: 2742e096f9947b4999183e682c0f1f3b405a68894bc9a2bbb4f140fb45f22a5c611c7e5759f88ea9b987bbd98a501f0bbb248638e83b494825881a6ccac60e76
+  metadata.gz: 145db314ab8d61384fbebbf8969310664c358c6b561bf1dbf742e97feb71497e58703d300c9d6b1e75159dfee27ee7a0173662a631ab143597b0b6633fff67ff
+  data.tar.gz: 423f772ec2e33618ad6e6567d20caa9a4c375c8c05a5cb8425b681010ee89ecddda2fd9a6ddde0c2ab0777962c1d9e51cd3ec69f28236cc0e1390cdf25ccd90e

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [0.2.0] - 2026-05-10
+
+Driven by an empirical probe of v0.1.0 against a 39-file Next.js production
+slice (`reserv-web/src/components/rolloverbook`). The slice exposed three
+return-shape gaps and a crash on nested destructure; this release fixes all
+four. Probe outcome: 33/39 → **39/39 emit**.
+
+### Fixed
+
+- **Nested-destructured props no longer crash the lowering.**
+  `function X({ outer: { inner } })` previously surfaced as
+  `Inflector.underscore(nil)` in the backend. The lowering now uses the
+  outer key as the prop name. Renamed destructures (`{ outer: inner }`)
+  similarly use the source-side key (the prop name the parent passes),
+  not the renamed local.
+
+### Added — return-shape lowering
+
+- **Top-level conditional / short-circuit returns** —
+  `return cond ? <A/> : <B/>` and `return cond && <A/>` now lower to
+  IR::Conditional via a new return-position dispatcher. Previously raised
+  "unexpected JSX node in lowering: ConditionalExpression".
+- **Multi-branch `if/else if/else` all-return bodies** — components
+  whose every return path lives inside an if-chain (no top-level
+  unconditional return) lower to a chained IR::Conditional. Branches
+  may be braced single-statement blocks (`if (x) { return <A/>; }`) or
+  bare returns (`if (x) return <A/>;`). Branches with side-effect
+  statements before the return still raise — those imply behavior we
+  can't preserve.
+
 ## [Unreleased]
 
 ### Added — translator (lowering)

data/lib/jsx_rosetta/ir/lowering.rb

@@ -209,14 +209,8 @@ module JsxRosetta
 
       def lower_object_prop(property)
         value = property[:value]
-        if value.type == "AssignmentPattern"
-          Prop.new(
-            name: value[:left][:name],
-            default: Interpolation.new(expression: source_of(value[:right]))
-          )
-        else
-          Prop.new(name: value[:name], default: nil)
-        end
+        default = (Interpolation.new(expression: source_of(value[:right])) if value.type == "AssignmentPattern")
+        Prop.new(name: property[:key][:name], default: default)
       end
 
       def lower_function_body(body)
@@ -224,9 +218,12 @@ module JsxRosetta
         when "BlockStatement"
           collect_local_bindings(body[:body])
           return_stmt = body[:body].find { |stmt| stmt.type == "ReturnStatement" }
-          raise lowering_error("component function has no return statement", node: body) unless return_stmt
+          return lower_return_value(return_stmt[:argument]) if return_stmt
 
-          lower_jsx(return_stmt[:argument])
+          chained = lower_if_return_chain_from_body(body[:body])
+          return chained if chained
+
+          raise lowering_error("component function has no return statement", node: body)
         when "JSXElement", "JSXFragment"
           @local_jsx = {}
           lower_jsx(body)
@@ -235,6 +232,65 @@ module JsxRosetta
         end
       end
 
+      # Dispatch a value in return position. Distinct from lower_jsx because
+      # `return cond ? <A/> : <B/>` and `return cond && <A/>` are valid return
+      # shapes that aren't JSX nodes and need to lower as Conditional.
+      def lower_return_value(node)
+        case node.type
+        when "ConditionalExpression" then lower_ternary_expression(node)
+        when "LogicalExpression" then lower_logical_expression(node)
+        else lower_jsx(node)
+        end
+      end
+
+      # Recognize a body whose only return paths are inside an
+      # `if/else if/else` chain at the bottom (no unconditional return).
+      # Lowers the chain to nested IR::Conditional. Returns nil when the
+      # shape doesn't fit.
+      def lower_if_return_chain_from_body(statements)
+        if_stmt = statements.last
+        return nil unless if_stmt.is_a?(AST::Node) && if_stmt.type == "IfStatement"
+
+        lower_if_return_chain(if_stmt)
+      end
+
+      def lower_if_return_chain(if_stmt)
+        consequent = lower_return_branch(if_stmt[:consequent])
+        return nil unless consequent
+
+        alternate_node = if_stmt[:alternate]
+        alternate = case alternate_node&.type
+                    when nil then nil
+                    when "IfStatement" then lower_if_return_chain(alternate_node)
+                    else lower_return_branch(alternate_node)
+                    end
+        return nil if alternate_node && alternate.nil?
+
+        Conditional.new(
+          test: Interpolation.new(expression: source_of(if_stmt[:test])),
+          consequent: consequent,
+          alternate: alternate
+        )
+      end
+
+      # An if-chain branch lowers to a return value only when it is a
+      # single-statement block ending in `return X;` (or a bare `return X;`
+      # without braces). Multi-statement branches imply side effects we
+      # don't preserve, so we bail.
+      def lower_return_branch(branch)
+        case branch.type
+        when "ReturnStatement"
+          branch[:argument] && lower_return_value(branch[:argument])
+        when "BlockStatement"
+          return nil if branch[:body].size != 1
+
+          inner = branch[:body].first
+          return nil unless inner.type == "ReturnStatement" && inner[:argument]
+
+          lower_return_value(inner[:argument])
+        end
+      end
+
       def collect_local_bindings(statements)
         @local_jsx = {}
         @local_arrows = {}

data/lib/jsx_rosetta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsxRosetta
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsx_rosetta
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Sean McCleary