fix(codegen): use = instead of := for error prop with named return params

The ? operator generated err := expr() for functions with named return
parameters like (err error), causing "no new variables on left side of :="
compile errors. Two root causes fixed:

1. BARE: generateTupleErrorPropBare always emitted := without checking
   for named return collision. Now detects named error returns via
   InferEnclosingFunctionNamedErrorReturn() and uses = when matched.

2. STATEMENT: stmt_finder.go only recognized := (DEFINE), not = (ASSIGN),
   causing result = getData()? to be classified as bare expression and
   dropping the user's LHS variable. Added ASSIGN token recognition with
   IsPlainAssign flag propagated through to code generators.

- Reproduction test: tests/golden/error_prop_named_return
- Multimodel review: Phase A APPROVE (2/2), Phase B APPROVE (2/2)
- Session: dev-fix-20260328-184322-392f98a3

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: erudenko

pkg/ast/stmt_finder.go

@@ -40,6 +40,11 @@ type StmtLocation struct {
 	LambdaBodyStart int           // Start byte position of lambda body
 	LambdaBodyEnd   int           // End byte position of lambda body
 
+	// IsPlainAssign is true when the LHS was written with = (not :=).
+	// Used to emit plain assignment (=) instead of short declaration (:=) in generated code,
+	// which is required when the target variable is a named return parameter.
+	IsPlainAssign bool
+
 	// Source location for LSP (1-indexed, like GuardLocation)
 	Line   int // 1-indexed line number of the statement
 	Column int // 1-indexed column number
@@ -124,6 +129,19 @@ func FindErrorPropStatements(src []byte) ([]StmtLocation, error) {
 				}
 				continue
 			}
+			// Check for "ident =" plain assignment (named return params or pre-declared vars)
+			if i+1 < len(tokens) && tokens[i+1].Kind == tokenizer.ASSIGN {
+				loc := scanForQuestionMark(tokens, i)
+				if loc != nil {
+					loc.Kind = StmtErrorPropAssign
+					loc.VarName = t.Lit
+					loc.IsPlainAssign = true
+					locations = append(locations, *loc)
+					// Skip past this statement
+					i = findTokenAtByte(tokens, loc.End)
+				}
+				continue
+			}
 			// Check for tuple assignment "a, b :=" pattern
 			// Scan ahead past comma-separated identifiers to find :=
 			defineIdx, tupleLHS := findDefineAfterTupleLHSWithNames(tokens, i)

pkg/codegen/type_inference.go

@@ -303,6 +303,49 @@ func findInnermostEnclosingFunc(src []byte, exprPos int) enclosingFuncInfo {
 	return enclosingFuncInfo{found: true, name: best.name, results: best.results}
 }
 
+// InferEnclosingFunctionNamedReturnParams returns the set of named return
+// parameter identifiers for the innermost function enclosing exprPos.
+// Returns nil if the function has no named returns or cannot be located.
+func InferEnclosingFunctionNamedReturnParams(src []byte, exprPos int) map[string]bool {
+	info := findInnermostEnclosingFunc(src, exprPos)
+	if !info.found || info.results == nil {
+		return nil
+	}
+	names := make(map[string]bool)
+	for _, field := range info.results.List {
+		for _, id := range field.Names {
+			if id.Name != "" && id.Name != "_" {
+				names[id.Name] = true
+			}
+		}
+	}
+	if len(names) == 0 {
+		return nil
+	}
+	return names
+}
+
+// InferEnclosingFunctionNamedErrorReturn returns the name of the named return parameter
+// whose type is `error`, for the innermost function enclosing exprPos.
+// Returns "" if no such named return exists or the function cannot be located.
+func InferEnclosingFunctionNamedErrorReturn(src []byte, exprPos int) string {
+	info := findInnermostEnclosingFunc(src, exprPos)
+	if !info.found || info.results == nil {
+		return ""
+	}
+	for _, field := range info.results.List {
+		// Check if this field's type is the built-in "error" interface
+		if ident, ok := field.Type.(*ast.Ident); ok && ident.Name == "error" {
+			for _, id := range field.Names {
+				if id.Name != "" && id.Name != "_" {
+					return id.Name
+				}
+			}
+		}
+	}
+	return ""
+}
+
 // InferEnclosingFunctionReturnsResult checks if the enclosing function returns a Result type.
 // Returns the Result's T type if it does, empty string otherwise.
 // For example, for `func foo() Result[User, error]`, returns "User".

pkg/transpiler/ast_transformer.go

@@ -707,9 +707,33 @@ func transformErrorPropStatements(src []byte, originalSrc []byte, filename strin
 	result := src
 	var lineMappings []sourcemap.LineMapping
 	var columnMappings []sourcemap.ColumnMapping
-	// Start counter at len(locations) and decrement, so first statement in source
-	// gets tmp/err, second gets tmp1/err1, etc. (we process end-to-beginning)
-	counter := len(locations)
+	// Count only the locations that generate fresh (counter-named) variables.
+	// Locations that use named return parameters directly (isPlainAssign with a named error
+	// return, or bare statements whose errVar is a named return) do NOT consume a counter slot.
+	// This ensures: first counter-consuming statement in source gets tmp/err (no suffix),
+	// second gets tmp1/err1, etc.
+	counterConsuming := 0
+	for _, loc := range locations {
+		switch loc.Kind {
+		case ast.StmtErrorPropAssign, ast.StmtErrorPropLet:
+			if loc.IsPlainAssign {
+				// Uses named error return directly — no counter slot needed
+				if codegen.InferEnclosingFunctionNamedErrorReturn(src, loc.ExprStart) == "" {
+					counterConsuming++
+				}
+			} else {
+				counterConsuming++
+			}
+		case ast.StmtErrorPropBare:
+			// Uses named error return directly when the function has one — no counter slot needed
+			if codegen.InferEnclosingFunctionNamedErrorReturn(src, loc.ExprStart) == "" {
+				counterConsuming++
+			}
+		default:
+			// Return statements and other kinds do not generate new variables
+		}
+	}
+	counter := counterConsuming
 
 	// First pass: calculate all deltas to know final positions
 	// We need to track byte deltas from transforms to calculate correct Go positions
@@ -764,7 +788,7 @@ func transformErrorPropStatements(src []byte, originalSrc []byte, filename strin
 			if loc.TupleLHS != "" {
 				varNameOrTuple = loc.TupleLHS
 			}
-			generated = generateErrorPropStatementAdvanced(result, exprBytes, loc.ExprStart, varNameOrTuple, returnTypes, &counter, loc.ErrorKind, loc.ErrorContext, loc.LambdaParam, lambdaBody, resolver)
+			generated = generateErrorPropStatementAdvanced(result, exprBytes, loc.ExprStart, varNameOrTuple, returnTypes, &counter, loc.ErrorKind, loc.ErrorContext, loc.LambdaParam, lambdaBody, resolver, loc.IsPlainAssign)
 			// Calculate LHS lengths for column mapping
 			// Dingo: "varName := " or "a, b := " for tuples
 			dingoLHSLen = len(varNameOrTuple) + 4 // " := " or " = " (always 4 with leading space consideration)
@@ -946,7 +970,7 @@ func transformErrorPropStatements(src []byte, originalSrc []byte, filename strin
 //	tmp := expr; if tmp.IsErr() { return dgo.Err[T, E](tmp.MustErr()) }; data := tmp.MustOk()
 //
 // Context and Lambda variants wrap the error appropriately.
-func generateErrorPropStatementAdvanced(src []byte, expr []byte, exprPos int, varName string, returnTypes []string, counter *int, errorKind ast.ErrorPropKind, errorContext string, lambdaParam string, lambdaBody []byte, resolver *codegen.TypeResolver) []byte {
+func generateErrorPropStatementAdvanced(src []byte, expr []byte, exprPos int, varName string, returnTypes []string, counter *int, errorKind ast.ErrorPropKind, errorContext string, lambdaParam string, lambdaBody []byte, resolver *codegen.TypeResolver, isPlainAssign bool) []byte {
 	// Check if expression returns a Result type (use resolver for cross-file types)
 	isResult, exprOkType, exprErrType := codegen.InferExprReturnsResultWithResolver(src, expr, exprPos, resolver)
 
@@ -955,7 +979,7 @@ func generateErrorPropStatementAdvanced(src []byte, expr []byte, exprPos int, va
 	}
 
 	// Original tuple-based error propagation
-	return generateTupleErrorPropStatement(expr, varName, returnTypes, counter, errorKind, errorContext, lambdaParam, lambdaBody, src, exprPos)
+	return generateTupleErrorPropStatement(expr, varName, returnTypes, counter, errorKind, errorContext, lambdaParam, lambdaBody, src, exprPos, isPlainAssign)
 }
 
 // generateResultErrorPropStatement generates code for Result[T, E] error propagation.
@@ -1072,35 +1096,63 @@ func generateResultErrorPropStatement(expr []byte, varName string, counter *int,
 // Pattern for Result-returning enclosing function:
 //
 //	tmp, err := expr; if err != nil { return dgo.Err[T, E](err) }; data := tmp
-func generateTupleErrorPropStatement(expr []byte, varName string, returnTypes []string, counter *int, errorKind ast.ErrorPropKind, errorContext string, lambdaParam string, lambdaBody []byte, src []byte, exprPos int) []byte {
+func generateTupleErrorPropStatement(expr []byte, varName string, returnTypes []string, counter *int, errorKind ast.ErrorPropKind, errorContext string, lambdaParam string, lambdaBody []byte, src []byte, exprPos int, isPlainAssign bool) []byte {
 	var buf bytes.Buffer
 
 	// Check if varName contains comma - if so, it's a tuple LHS like "a, b"
 	isTupleLHS := strings.Contains(varName, ",")
 
+	// When isPlainAssign is true, the user wrote `varName = expr?` (plain = not :=).
+	// This happens when varName is a named return parameter.
+	// In that case, use the actual named error return variable and plain = assignment,
+	// instead of counter-generated names and :=.
+	var namedErrVar string
+	if isPlainAssign {
+		namedErrVar = codegen.InferEnclosingFunctionNamedErrorReturn(src, exprPos)
+	}
+
 	// Generate unique variable names
 	var tmpVar, errVar string
-	if *counter == 1 {
-		tmpVar = "tmp"
-		errVar = "err"
+	if namedErrVar != "" {
+		// Plain assign with named return: use named error return directly, don't consume counter slot.
+		// The counter is only consumed for generated (counter-named) variables to keep numbering stable.
+		errVar = namedErrVar
 	} else {
-		tmpVar = fmt.Sprintf("tmp%d", *counter-1)
-		errVar = fmt.Sprintf("err%d", *counter-1)
+		if *counter == 1 {
+			tmpVar = "tmp"
+			errVar = "err"
+		} else {
+			tmpVar = fmt.Sprintf("tmp%d", *counter-1)
+			errVar = fmt.Sprintf("err%d", *counter-1)
+		}
+		*counter--
 	}
-	*counter--
 
 	// Check if enclosing function returns Result[T, E]
 	// If so, we need to return dgo.Err[T, E](err) instead of tuple
 	enclosingReturnsResult, enclosingOkType, enclosingErrType := codegen.InferEnclosingFunctionResultTypes(src, exprPos)
 
-	// For tuple LHS, generate: a, b, err := expr
-	// For single LHS, generate: tmp, err := expr
+	// For tuple LHS, generate: a, b, err := expr (or a, b, err = expr for plain assign)
+	// For single LHS with plain assign (named return), generate: varName, err = expr
+	// For single LHS with define, generate: tmp, err := expr
 	if isTupleLHS {
 		// Tuple LHS: fullKey, keyHash, err := util.GeneratePersonalKey()
+		declOp := " := "
+		if isPlainAssign {
+			declOp = " = "
+		}
 		buf.WriteString(varName)
 		buf.WriteString(", ")
 		buf.WriteString(errVar)
-		buf.WriteString(" := ")
+		buf.WriteString(declOp)
+		buf.Write(expr)
+		buf.WriteByte('\n')
+	} else if isPlainAssign && namedErrVar != "" {
+		// Single LHS with named return: result, err = expr
+		buf.WriteString(varName)
+		buf.WriteString(", ")
+		buf.WriteString(errVar)
+		buf.WriteString(" = ")
 		buf.Write(expr)
 		buf.WriteByte('\n')
 	} else {
@@ -1177,18 +1229,22 @@ func generateTupleErrorPropStatement(expr []byte, varName string, returnTypes []
 		}
 	}
 
-	buf.WriteString("\n}\n")
-
 	// For tuple LHS, variables are already assigned (fullKey, keyHash, err := expr)
-	// For single LHS, we need: varName := tmp
-	if !isTupleLHS {
+	// For single LHS with plain assign (named return), variables are also already assigned (varName, err = expr)
+	// For single LHS with define, we need: varName := tmp
+	if !isTupleLHS && !(isPlainAssign && namedErrVar != "") {
+		buf.WriteString("\n}\n")
 		buf.WriteString(varName)
 		if varName == "_" {
 			buf.WriteString(" = ")
 		} else {
 			buf.WriteString(" := ")
 		}
 		buf.WriteString(tmpVar)
+	} else {
+		// No trailing assignment — end the if block without an extra newline
+		// to avoid introducing a blank line before the next source statement.
+		buf.WriteString("\n}")
 	}
 
 	return buf.Bytes()
@@ -1698,14 +1754,28 @@ func generateResultErrorPropBare(expr []byte, counter *int, errorKind ast.ErrorP
 func generateTupleErrorPropBare(src []byte, expr []byte, exprPos int, returnTypes []string, counter *int, errorKind ast.ErrorPropKind, errorContext string, lambdaParam string, lambdaBody []byte, resolver *codegen.TypeResolver) []byte {
 	var buf bytes.Buffer
 
+	// Check if there is a named error return parameter in the enclosing function.
+	// If so, use that variable name directly (do NOT consume a counter slot).
+	// This avoids "no new variables on left side of :=" compile errors.
+	namedErrReturn := codegen.InferEnclosingFunctionNamedErrorReturn(src, exprPos)
+
 	// Generate unique variable names
 	var errVar string
-	if *counter == 1 {
-		errVar = "err"
+	var errDeclOp string
+	if namedErrReturn != "" {
+		// Use the named error return directly — no new variable needed
+		errVar = namedErrReturn
+		errDeclOp = " = "
+		// Do NOT decrement counter: this location uses named returns, not a fresh counter slot
 	} else {
-		errVar = fmt.Sprintf("err%d", *counter-1)
+		if *counter == 1 {
+			errVar = "err"
+		} else {
+			errVar = fmt.Sprintf("err%d", *counter-1)
+		}
+		*counter--
+		errDeclOp = " := "
 	}
-	*counter--
 
 	// Detect return count: 1 = single (error only), 2+ = multi (T, error), -1 = unknown
 	// Use the resolver for cross-file type resolution if available
@@ -1719,15 +1789,15 @@ func generateTupleErrorPropBare(src []byte, expr []byte, exprPos int, returnType
 	// because the user is explicitly not capturing any non-error return value.
 	// If a function returns (T, error) but user wrote a bare `foo()?`, they want to ignore T.
 	if returnCount == 1 || returnCount == -1 {
-		// Single return or unknown: err := expr
+		// Single return or unknown: err := expr (or err = expr for named returns)
 		// For bare statements, single-return is safer default (avoids "assignment mismatch" errors)
 		buf.WriteString(errVar)
-		buf.WriteString(" := ")
+		buf.WriteString(errDeclOp)
 	} else {
-		// Multi-return (returnCount > 1): _, err := expr
+		// Multi-return (returnCount > 1): _, err := expr (or _, err = expr for named returns)
 		buf.WriteString("_, ")
 		buf.WriteString(errVar)
-		buf.WriteString(" := ")
+		buf.WriteString(errDeclOp)
 	}
 	buf.Write(expr)
 	buf.WriteByte('\n')

tests/golden/error_prop_named_return.dingo

@@ -0,0 +1,37 @@
+package main
+
+// REGRESSION: named return error prop generates := instead of = — Fixed in /dev:fix session dev-fix-20260328-184322-392f98a3
+
+// mayFail is a helper returning only an error, used in the BARE sub-bug case.
+func mayFail() error {
+	return nil
+}
+
+// getData is a helper returning a value and an error, used in the STATEMENT sub-bug case.
+func getData() (string, error) {
+	return "hello", nil
+}
+
+// wrapper demonstrates the BARE sub-bug:
+// `mayFail()?` inside a function with named return `err error` must generate
+// `err = mayFail()` (plain assignment), NOT `err := mayFail()` (short declaration).
+func wrapper() (err error) {
+	mayFail()?
+	return nil
+}
+
+// fetch demonstrates the STATEMENT sub-bug:
+// `result = getData()?` inside a function with named returns `(result string, err error)`
+// must generate `result, err = getData()` (plain assignment on both sides),
+// NOT `_, err := getData()` (which discards result and re-declares err).
+func fetch() (result string, err error) {
+	result = getData()?
+	return
+}
+
+// normal has NO named return parameters — regression guard to ensure the common
+// case still generates the short-declaration `:=` form as expected.
+func normal() (string, error) {
+	val := getData()?
+	return val, nil
+}

tests/golden/error_prop_named_return.go.golden

@@ -0,0 +1,47 @@
+package main
+
+// REGRESSION: named return error prop generates := instead of = — Fixed in /dev:fix session dev-fix-20260328-184322-392f98a3
+
+// mayFail is a helper returning only an error, used in the BARE sub-bug case.
+func mayFail() error {
+	return nil
+}
+
+// getData is a helper returning a value and an error, used in the STATEMENT sub-bug case.
+func getData() (string, error) {
+	return "hello", nil
+}
+
+// wrapper demonstrates the BARE sub-bug:
+// `mayFail()?` inside a function with named return `err error` must generate
+// `err = mayFail()` (plain assignment), NOT `err := mayFail()` (short declaration).
+func wrapper() (err error) {
+	err = mayFail()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// fetch demonstrates the STATEMENT sub-bug:
+// `result = getData()?` inside a function with named returns `(result string, err error)`
+// must generate `result, err = getData()` (plain assignment on both sides),
+// NOT `_, err := getData()` (which discards result and re-declares err).
+func fetch() (result string, err error) {
+	result, err = getData()
+	if err != nil {
+		return "", err
+	}
+	return
+}
+
+// normal has NO named return parameters — regression guard to ensure the common
+// case still generates the short-declaration `:=` form as expected.
+func normal() (string, error) {
+	tmp, err := getData()
+	if err != nil {
+		return "", err
+	}
+	val := tmp
+	return val, nil
+}