fix: Prioritize channel receive detection over type hoisting

Fixed critical bug where channel receive variables (currentState := <-channel)
were incorrectly treated as hoisted variables instead of channel receives.

Root cause:
- inferTypeFromExpr returns the element type for channel receives
- analyzeComponentBody checked inferredType != nil BEFORE checking hasChannelOp
- Since both were true, it took the hoisted vars branch and skipped channel tracking
- This caused g.channelReceiveVars to be empty
- Result: No channel listeners were generated, breaking reactive updates

Fix:
1. Reorder checks in analyzeComponentBody to check hasChannelOp FIRST
2. Reorder checks in generateBody for consistency
3. Skip channel receive vars when adding struct fields

Now works correctly:
- Channel receives tracked in channelReceiveVars map
- Listeners generated for channels that are received from
- Local variables created in Render from struct fields
- Calculator and other examples with channel-based state now work

Testing:
- All codegen tests pass
- Calculator buttons update state correctly
- WebGPU cube controls update reactively

Author: claude

examples/calculator/calculator_gen.go

@@ -371,12 +371,16 @@ func (g *Generator) analyzeComponentBody(comp *guixast.Component) {
 	if comp.Body != nil {
 		for _, varDecl := range comp.Body.VarDecls {
 			if len(varDecl.Names) == 1 && len(varDecl.Values) == 1 {
-				if g.inferTypeFromExpr(varDecl.Values[0]) != nil {
-					g.hoistedVars[varDecl.Names[0]] = true
-				} else if varDecl.Values[0].Left != nil && varDecl.Values[0].Left.ChannelOp != nil {
+				hasChannelOp := varDecl.Values[0].Left != nil && varDecl.Values[0].Left.ChannelOp != nil
+				inferredType := g.inferTypeFromExpr(varDecl.Values[0])
+
+				// Check for channel receive FIRST (has priority over hoisting)
+				if hasChannelOp {
 					// Track channel receive: currentState := <-stateChannel
 					channelName := varDecl.Values[0].Left.ChannelOp.Channel
 					g.channelReceiveVars[varDecl.Names[0]] = capitalize(channelName)
+				} else if inferredType != nil {
+					g.hoistedVars[varDecl.Names[0]] = true
 				}
 			}
 		}
@@ -970,10 +974,16 @@ func (g *Generator) generateComponentStruct(comp *guixast.Component) *ast.GenDec
 
 	// Add VarDecl fields from component body (for stateful variables)
 	// This ensures channels and components persist across renders
+	// But skip channel receive variables - those are managed by channel listeners
 	if comp.Body != nil {
 		for _, varDecl := range comp.Body.VarDecls {
 			for i, name := range varDecl.Names {
 				if i < len(varDecl.Values) {
+					// Skip channel receive variables (they become local vars in Render)
+					if g.channelReceiveVars != nil && g.channelReceiveVars[name] != "" {
+						continue
+					}
+
 					// Determine the type from the value expression
 					varType := g.inferTypeFromExpr(varDecl.Values[i])
 					if varType != nil {
@@ -1540,18 +1550,34 @@ func (g *Generator) generateBody(body *guixast.Body) ast.Expr {
 		// and initialized in the constructor - skip them here in Render
 		// All other VarDecls remain as local variables (including multiple assignments)
 		for _, varDecl := range body.VarDecls {
-			// Check if ALL variables in this decl can be hoisted
-			// For now, only hoist if there's a single variable with an inferable type
-			canHoist := len(varDecl.Names) == 1 && len(varDecl.Values) == 1 &&
-				g.inferTypeFromExpr(varDecl.Values[0]) != nil
-
-			// Check if this is a channel receive variable (skip - will be accessed via c.current<ChannelName>)
+			// Check if this is a channel receive variable FIRST (has priority)
 			isChannelReceive := len(varDecl.Names) == 1 &&
 				g.channelReceiveVars != nil &&
 				g.channelReceiveVars[varDecl.Names[0]] != ""
 
-			if canHoist || isChannelReceive {
-				// Hoisted field or channel receive - skip initialization in Render
+			// Check if ALL variables in this decl can be hoisted
+			// For now, only hoist if there's a single variable with an inferable type
+			// BUT exclude channel receives from hoisting (they're handled separately below)
+			canHoist := !isChannelReceive && len(varDecl.Names) == 1 && len(varDecl.Values) == 1 &&
+				g.inferTypeFromExpr(varDecl.Values[0]) != nil
+
+			if isChannelReceive {
+				// Channel receive variable - replace with assignment from struct field
+				// Example: currentState := c.currentStateChannel
+				varName := varDecl.Names[0]
+				channelName := g.channelReceiveVars[varName]
+				stmts = append(stmts, &ast.AssignStmt{
+					Lhs: []ast.Expr{ast.NewIdent(varName)},
+					Tok: token.DEFINE,
+					Rhs: []ast.Expr{
+						&ast.SelectorExpr{
+							X:   ast.NewIdent("c"),
+							Sel: ast.NewIdent("current" + channelName),
+						},
+					},
+				})
+			} else if canHoist {
+				// Hoisted field - skip initialization in Render
 				continue
 			} else {
 				// Local variable(s) - generate: name := value or n, err := value