refactor(naming): Implement no-number-first variable naming convention

Changes all code generators to use idiomatic Go naming pattern where the first
occurrence of a temporary variable has no number suffix, with subsequent
occurrences numbered starting at 1.

Pattern:
- First: tmp, err, coalesce (no number)
- Second: tmp1, err1, coalesce1
- Third: tmp2, err2, coalesce2

Changes:
- error_prop.go: tmp/err generation logic updated
- null_coalesce.go: coalesce variable naming updated, counter init fixed
- safe_nav.go: Counter init fixed, camelCase for pointer mode (userTmp vs __user_tmp0)
- plugin.go: NextTempVar() updated for no-number-first
- CLAUDE.md: Documentation updated with new convention
- All golden test files regenerated (17 files)

This prevents the old pattern (tmp1, tmp2, tmp3) and zero-based pattern (tmp0, tmp1).
Generated code now looks more hand-written and idiomatic.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: erudenko

CLAUDE.md

@@ -267,22 +267,24 @@ See `ai-docs/claude-research.md` and `ai-docs/gemini_research.md` for details:
 All code generators MUST follow these naming rules:
 
 1. **No Underscores - Use camelCase**
-   - ✅ Correct: `tmp1`, `err1`, `coalesce1`
+   - ✅ Correct: `tmp`, `tmp1`, `err`, `err1`, `coalesce`
    - ❌ Wrong: `__tmp0`, `__err0`, `__coalesce0`
 
-2. **One-Based Indexing - Start at 1**
-   - ✅ Correct: `tmp1`, `tmp2`, `tmp3`
-   - ❌ Wrong: `tmp0`, `tmp1`, `tmp2`
+2. **No-Number-First Pattern**
+   - ✅ Correct: First `tmp`, then `tmp1`, `tmp2`
+   - ✅ Correct: First `err`, then `err1`, `err2`
+   - ❌ Wrong: `tmp1`, `tmp2`, `tmp3` (all numbered)
+   - ❌ Wrong: `tmp0`, `tmp1`, `tmp2` (zero-based)
 
 3. **Counter Initialization**
    - ✅ Correct: `counter = 1` or `counter := 1`
    - ❌ Wrong: `counter = 0` or `counter := 0`
 
 **Affected Components:**
-- `pkg/preprocessor/error_prop.go` - Error propagation (`tmp1`, `err1`)
-- `pkg/preprocessor/null_coalesce.go` - Null coalescing (`coalesce1`, `coalesce2`)
-- `pkg/preprocessor/safe_nav.go` - Safe navigation (`val1`, `val2`)
-- `pkg/plugin/plugin.go` - Plugin temp vars (`tmp1`, `tmp2`)
+- `pkg/preprocessor/error_prop.go` - Error propagation (`tmp`, `err` → `tmp1`, `err1`)
+- `pkg/preprocessor/null_coalesce.go` - Null coalescing (`coalesce` → `coalesce1`)
+- `pkg/preprocessor/safe_nav.go` - Safe navigation (`user` → `user1`, `__user_tmp` → `__user_tmp1`)
+- `pkg/plugin/plugin.go` - Plugin temp vars (`tmp` → `tmp1`)
 
 **Rationale:**
 - Go convention: camelCase for local variables

pkg/plugin/plugin.go

@@ -243,7 +243,15 @@ func (ctx *Context) NextTempVar() string {
 	if ctx.TempVarCounter == 0 {
 		ctx.TempVarCounter = 1
 	}
-	varName := fmt.Sprintf("tmp%d", ctx.TempVarCounter)
+
+	// No-number-first pattern: first tmp has no number, then tmp1, tmp2, etc.
+	varName := ""
+	if ctx.TempVarCounter == 1 {
+		varName = "tmp"
+	} else {
+		varName = fmt.Sprintf("tmp%d", ctx.TempVarCounter-1)
+	}
+
 	ctx.TempVarCounter++
 	return varName
 }

pkg/preprocessor/error_prop.go

@@ -122,7 +122,8 @@ func (it *ImportTracker) GetNeededImports() []string {
 //
 // Example Expansion:
 //   Dingo:  let x = ReadFile(path)?
-//   Go:     tmp1, err1 := ReadFile(path)
+//   Go (first):    tmp, err := ReadFile(path)
+//   Go (second):   tmp1, err1 := AnotherCall()
 //           // dingo:s:1
 //           if err1 != nil {
 //               return nil, err1
@@ -336,8 +337,20 @@ func (e *ErrorPropProcessor) expandAssignment(matches []string, expr string, err
 	// Track function call for import detection
 	e.trackFunctionCallInExpr(exprClean)
 
-	tmpVar := fmt.Sprintf("tmp%d", e.tryCounter)
-	errVar := fmt.Sprintf("err%d", e.tryCounter)
+	// No-number-first pattern: first occurrence has no number
+	tmpVar := ""
+	if e.tryCounter == 1 {
+		tmpVar = "tmp"
+	} else {
+		tmpVar = fmt.Sprintf("tmp%d", e.tryCounter-1)
+	}
+
+	errVar := ""
+	if e.tryCounter == 1 {
+		errVar = "err"
+	} else {
+		errVar = fmt.Sprintf("err%d", e.tryCounter-1)
+	}
 	e.tryCounter++
 
 	// Calculate exact position of ? operator for accurate source mapping
@@ -519,15 +532,26 @@ func (e *ErrorPropProcessor) expandReturn(matches []string, expr string, errMsg
 	}
 
 	// Generate temporary variable names for all non-error values
-	// For multi-value returns, use sequential counters: tmp1, tmp2, tmp3, ...
-	// CRITICAL FIX: Use base counter for error variable, then increment once for all vars
+	// No-number-first pattern: first tmp/err has no number, then tmp1/err1, tmp2/err2, etc.
 	baseCounter := e.tryCounter
 	tmpVars := []string{}
 	for i := 0; i < numNonErrorReturns; i++ {
-		tmpVars = append(tmpVars, fmt.Sprintf("tmp%d", baseCounter))
+		var tmpVar string
+		if baseCounter == 1 {
+			tmpVar = "tmp"
+		} else {
+			tmpVar = fmt.Sprintf("tmp%d", baseCounter-1)
+		}
+		tmpVars = append(tmpVars, tmpVar)
 		baseCounter++
 	}
-	errVar := fmt.Sprintf("err%d", e.tryCounter)
+
+	var errVar string
+	if e.tryCounter == 1 {
+		errVar = "err"
+	} else {
+		errVar = fmt.Sprintf("err%d", e.tryCounter-1)
+	}
 	e.tryCounter++
 
 	// Calculate exact position of ? operator for accurate source mapping

pkg/preprocessor/null_coalesce.go

@@ -29,7 +29,7 @@ const (
 func NewNullCoalesceProcessor() *NullCoalesceProcessor {
 	return &NullCoalesceProcessor{
 		typeDetector: NewTypeDetector(),
-		tmpCounter:   0,
+		tmpCounter:   1,
 		mappings:     []Mapping{},
 	}
 }
@@ -660,7 +660,13 @@ func (n *NullCoalesceProcessor) generateIIFE(chain []string, leftType TypeKind,
 
 		if i == 0 {
 			// First operand: evaluate once and check
-			tmpVar := fmt.Sprintf("coalesce%d", n.tmpCounter)
+			// No-number-first pattern
+			tmpVar := ""
+			if n.tmpCounter == 1 {
+				tmpVar = "coalesce"
+			} else {
+				tmpVar = fmt.Sprintf("coalesce%d", n.tmpCounter-1)
+			}
 			n.tmpCounter++
 
 			buf.WriteString(fmt.Sprintf("%s := %s; ", tmpVar, operand))
@@ -679,7 +685,13 @@ func (n *NullCoalesceProcessor) generateIIFE(chain []string, leftType TypeKind,
 			}
 		} else {
 			// Subsequent operands in chain: evaluate and check
-			tmpVar := fmt.Sprintf("coalesce%d", n.tmpCounter)
+			// No-number-first pattern
+			tmpVar := ""
+			if n.tmpCounter == 1 {
+				tmpVar = "coalesce"
+			} else {
+				tmpVar = fmt.Sprintf("coalesce%d", n.tmpCounter-1)
+			}
 			n.tmpCounter++
 
 			buf.WriteString(fmt.Sprintf("%s := %s; ", tmpVar, operand))

pkg/preprocessor/safe_nav.go

@@ -170,7 +170,7 @@ func classifyType(typeName string) TypeKind {
 func NewSafeNavProcessor() *SafeNavProcessor {
 	return &SafeNavProcessor{
 		typeDetector: NewTypeDetector(),
-		tmpCounter:   0,
+		tmpCounter:   1,
 		mappings:     []Mapping{},
 	}
 }
@@ -743,7 +743,13 @@ func (s *SafeNavProcessor) generateOptionMode(base string, elements []ChainEleme
 		outputLinesGenerated += 3
 
 		// Unwrap to get the value
-		tmpVar := fmt.Sprintf("%s%d", base, s.tmpCounter)
+		// No-number-first pattern
+		tmpVar := ""
+		if s.tmpCounter == 1 {
+			tmpVar = base
+		} else {
+			tmpVar = fmt.Sprintf("%s%d", base, s.tmpCounter-1)
+		}
 		s.tmpCounter++
 		buf.WriteString(fmt.Sprintf("\t%s := %s.Unwrap()\n", tmpVar, currentVar))
 		outputLinesGenerated++
@@ -809,7 +815,13 @@ func (s *SafeNavProcessor) generatePointerMode(base string, elements []ChainElem
 		// Access the property or method
 		if i < len(elements)-1 {
 			// Not the last element - create intermediate variable to check next nil
-			tmpVar := fmt.Sprintf("__%s_tmp%d", base, i)
+			// CamelCase pattern without underscores
+			var tmpVar string
+			if i == 0 {
+				tmpVar = base + "Tmp"
+			} else {
+				tmpVar = fmt.Sprintf("%sTmp%d", base, i)
+			}
 			if elem.IsMethod {
 				buf.WriteString(fmt.Sprintf("\t%s := %s.%s(%s)\n", tmpVar, currentVar, elem.Name, elem.RawArgs))
 			} else {

tests/golden/error_prop_01_simple.go.golden

@@ -5,13 +5,13 @@ import (
 )
 
 func readConfig(path string) ([]byte, error) {
-	tmp1, err1 := os.ReadFile(path)
+	tmp, err := os.ReadFile(path)
 
-	if err1 != nil {
-		return nil, err1
+	if err != nil {
+		return nil, err
 	}
 	// dingo:e:1
-	var data = tmp1
+	var data = tmp
 	return data, nil
 
 }

tests/golden/error_prop_03_expression.go.golden

@@ -5,11 +5,11 @@ import (
 )
 
 func parseInt(s string) (int, error) {
-	tmp1, err1 := strconv.Atoi(s)
+	tmp, err := strconv.Atoi(s)
 
-	if err1 != nil {
-		return 0, err1
+	if err != nil {
+		return 0, err
 	}
 
-	return tmp1, nil
+	return tmp, nil
 }

tests/golden/error_prop_04_wrapping.go.golden

@@ -7,12 +7,12 @@ import (
 
 func readUserConfig(username string) ([]byte, error) {
 	path := "/home/" + username + "/config.json"
-	tmp1, err1 := os.ReadFile(path)
+	tmp, err := os.ReadFile(path)
 
-	if err1 != nil {
-		return nil, fmt.Errorf("failed to read user config: %w", err1)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read user config: %w", err)
 	}
 	// dingo:e:1
-	var data = tmp1
+	var data = tmp
 	return data, nil
 }

tests/golden/error_prop_05_complex_types.go.golden

@@ -10,22 +10,22 @@ type User struct {
 }
 
 func fetchUser(id int) (*User, error) {
-	tmp1, err1 := os.ReadFile("user.json")
+	tmp, err := os.ReadFile("user.json")
 
-	if err1 != nil {
-		return nil, err1
+	if err != nil {
+		return nil, err
 	}
 	// dingo:e:1
-	var data = tmp1
+	var data = tmp
 	return &User{ID: id, Name: string(data)}, nil
 }
 func getNames() ([]string, error) {
-	tmp1, err1 := os.ReadFile("names.txt")
+	tmp, err := os.ReadFile("names.txt")
 
-	if err1 != nil {
-		return nil, err1
+	if err != nil {
+		return nil, err
 	}
 	// dingo:e:1
-	var data = tmp1
+	var data = tmp
 	return []string{string(data)}, nil
 }

tests/golden/error_prop_06_mixed_context.go.golden

@@ -6,18 +6,18 @@ import (
 )
 
 func processData(path string) (int, error) {
-	tmp1, err1 := os.ReadFile(path)
+	tmp, err := os.ReadFile(path)
 
-	if err1 != nil {
-		return 0, err1
+	if err != nil {
+		return 0, err
 	}
 	// dingo:e:1
-	var data = tmp1
-	tmp2, err2 := strconv.Atoi(string(data))
+	var data = tmp
+	tmp1, err1 := strconv.Atoi(string(data))
 
-	if err2 != nil {
-		return 0, err2
+	if err1 != nil {
+		return 0, err1
 	}
 
-	return tmp2, nil
+	return tmp1, nil
 }