cleanup: simplify ARC fix code in exprs.go and stmts.go

- genPipeExpr: deduplicate ARC release+return across fat-fn and plain-fn branches
- callFatFn: remove unreachable bounds check (llArgsPreCoerce always has 1+len(argNodes) entries)
- emitDefers: remove redundant i<len(pendingDeferEnvs) and env!=nil guards
  (pendingDefers and pendingDeferEnvs are always kept in sync; buildEnv never
  returns nil, only constant.Null for the no-captures case)
- lambda params: inline one-use isRC variable

https://claude.ai/code/session_016ZZaZLVcvtzTmYVaM1pmAB

Author: claude

codegen/exprs.go

@@ -1312,24 +1312,17 @@ func (cg *CodeGen) genPipeExpr(block *ir.Block, e *ast.PipeExpr) (value.Value, e
 	if rightFn == nil {
 		return leftVal, nil
 	}
-	// If rightFn is a closure fat pointer {fn*, i8*}, call through it.
+	// Call through the function (fat-pointer or plain).
+	var result value.Value
 	if isFatFnPtr(rightFn.Type()) {
 		fnPtr := block.NewExtractValue(rightFn, 0)
 		envPtr := block.NewExtractValue(rightFn, 1)
 		fnType := fnPtr.Type().(*irtypes.PointerType).ElemType.(*irtypes.FuncType)
 		llArgs := cg.adaptArgs(block, []value.Value{envPtr, leftVal}, fnType)
-		result := block.NewCall(fnPtr, llArgs...)
-		// ARC: release the left-hand value if it is a temporary RC allocation.
-		if isRCTrackedType(leftVal.Type()) && !isCopyExpr(e.Left) {
-			cg.emitRelease(block, leftVal)
-		}
-		if irtypes.IsVoid(result.Type()) {
-			return nil, nil
-		}
-		return result, nil
+		result = block.NewCall(fnPtr, llArgs...)
+	} else {
+		result = block.NewCall(rightFn, leftVal)
 	}
-	// Plain function pointer.
-	result := block.NewCall(rightFn, leftVal)
 	// ARC: release the left-hand value if it is a temporary RC allocation.
 	if isRCTrackedType(leftVal.Type()) && !isCopyExpr(e.Left) {
 		cg.emitRelease(block, leftVal)
@@ -1842,9 +1835,6 @@ func (cg *CodeGen) callFatFn(block *ir.Block, fatPtr value.Value, argNodes []ast
 	// ARC: release temporary RC-tracked arguments (skip index 0 = env).
 	for i, astArg := range argNodes {
 		argIdx := i + 1 // offset by 1 for the env slot
-		if argIdx >= len(llArgsPreCoerce) {
-			break
-		}
 		preCoerce := llArgsPreCoerce[argIdx]
 		postCoerce := llArgs[argIdx]
 
@@ -1947,8 +1937,7 @@ func (cg *CodeGen) genLambdaExpr(block *ir.Block, e *ast.LambdaExpr) (value.Valu
 		// ARC: retain RC-tracked params so scope-exit release is balanced.
 		// Same convention as genFuncDeclAs: callee owns a reference.
 		cg.emitRetain(entry, param)
-		isRC := isRCTrackedType(pt)
-		cg.curScope.set(p.Name, &scopeEntry{val: alloca, isAlloc: true, isRC: isRC})
+		cg.curScope.set(p.Name, &scopeEntry{val: alloca, isAlloc: true, isRC: isRCTrackedType(pt)})
 	}
 
 	// For where-list bodies, the match subject is the first parameter so that

codegen/stmts.go

@@ -485,16 +485,11 @@ func (cg *CodeGen) emitDefers(block *ir.Block) error {
 		if _, err := cg.genExpr(block, cg.pendingDefers[i]); err != nil {
 			return err
 		}
-		// Free the env that was malloc'd for the thunk/panic path.
-		// The env is an i8* (may be null if there were no captures).
-		if i < len(cg.pendingDeferEnvs) {
-			env := cg.pendingDeferEnvs[i]
-			if env != nil {
-				// Only free non-null envs (captures present case).
-				if _, isNull := env.(*constant.Null); !isNull {
-					block.NewCall(cg.ensureFree(), env)
-				}
-			}
+		// Free the heap env that was malloc'd for the thunk/panic path.
+		// Skip the null sentinel emitted when there were no captures.
+		env := cg.pendingDeferEnvs[i]
+		if _, isNull := env.(*constant.Null); !isNull {
+			block.NewCall(cg.ensureFree(), env)
 		}
 	}
 	return nil