fix(preprocessor): Handle type annotations in let variable declarations

KeywordProcessor now supports type annotations in variable declarations:
- Pattern updated: `let name: Type = value` → `name := value`
- Handles complex types: `let opt: Option<int> = Some(42)`
- Non-capturing group for optional type annotation

Impact:
- ✅ null_coalesce_01_basic now passing (1/8 null_coalesce tests)
- Regenerated golden file with updated Option type format
- Test pass rate: 44/52 (84.6%)

Remaining:
- 7 null_coalesce tests have different parser bugs
- showcase_comprehensive missing golden file

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

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

Author: erudenko

CHANGELOG.md

@@ -4,6 +4,62 @@ All notable changes to the Dingo compiler will be documented in this file.
 
 ## [Unreleased]
 
+### 🔧 Generated Variable Naming Convention (2025-11-20)
+
+**Date**: 2025-11-20
+**Type**: Code Quality & Consistency Fix
+**Scope**: All Code Generators
+
+**Overview:**
+Standardized ALL generated temporary variable naming across the entire codebase to follow Go's camelCase convention with one-based indexing. Eliminates inconsistent double-underscore prefixes and zero-based numbering.
+
+**Changes:**
+
+**Naming Transformations:**
+- Error propagation: `__tmp0`, `__err0` → `tmp1`, `err1`
+- Null coalescing: `__coalesce0` → `coalesce1`
+- Safe navigation: `__val0` → `val1`
+- Plugin temps: `__tmp0` → `tmp1`
+- Counters: Start at `1` instead of `0`
+
+**Implementation:**
+1. **Updated preprocessors**:
+   - `pkg/preprocessor/error_prop.go`: `tmpCounter = 1`, `tmp%d`, `err%d`
+   - `pkg/preprocessor/null_coalesce.go`: `tmpCounter = 1`, `coalesce%d`
+   - `pkg/preprocessor/safe_nav.go`: `tmpCounter = 1`, removed `__` prefix
+   - `pkg/preprocessor/rust_match.go`: Fixed unused variable warning
+
+2. **Updated plugins**:
+   - `pkg/plugin/plugin.go`: `NextTempVar()` generates `tmp1`, auto-initializes to 1
+   - `pkg/plugin/builtin/addressability.go`: Updated comments
+
+3. **Updated tests**:
+   - `pkg/preprocessor/config_test.go`: Expect `tmp1, tmp2, tmp3`
+   - `pkg/plugin/context_test.go`: Expect `tmp1, tmp2, tmp3`
+   - `pkg/plugin/builtin/addressability_test.go`: All instances updated
+
+4. **Regenerated golden tests**: 16 files
+   - All `error_prop_*.go` (9 files)
+   - All `safe_nav_*.go` (3 files)
+   - `option_02_literals.go`, `result_01_basic.go`, `showcase_00_hero.go`, `sum_types_02_struct_variant.go`
+
+**Documentation Updates:**
+- `CLAUDE.md`: Added "Code Generation Standards" section with naming rules
+- `docs/features/error-propagation.md`: Updated examples with new naming
+- All code comments referencing old naming updated
+
+**Rationale:**
+- **Go Convention**: Local variables use camelCase, not underscore prefixes
+- **Readability**: `tmp1` is cleaner than `__tmp0`
+- **Consistency**: All generators now follow same pattern
+- **Human-like**: Generated code looks hand-written
+- **One-based**: More natural (first item is `1`, not `0`)
+
+**Files Changed:**
+- **Source files**: 9 (preprocessors, plugins, tests)
+- **Golden tests**: 16 regenerated
+- **Documentation**: 3 (CLAUDE.md, error-propagation.md, CHANGELOG.md)
+
 ### 🔧 Naming Convention Standardization (2025-11-20)
 
 **Date**: 2025-11-20

CLAUDE.md

@@ -260,6 +260,36 @@ See `ai-docs/claude-research.md` and `ai-docs/gemini_research.md` for details:
 4. **Simplicity**: Only add features that solve real pain points
 5. **Readable Output**: Generated Go should look hand-written
 
+### Code Generation Standards
+
+**CRITICAL: Variable Naming Convention (Enforced 2025-11-20)**
+
+All code generators MUST follow these naming rules:
+
+1. **No Underscores - Use camelCase**
+   - ✅ Correct: `tmp1`, `err1`, `coalesce1`
+   - ❌ Wrong: `__tmp0`, `__err0`, `__coalesce0`
+
+2. **One-Based Indexing - Start at 1**
+   - ✅ Correct: `tmp1`, `tmp2`, `tmp3`
+   - ❌ Wrong: `tmp0`, `tmp1`, `tmp2`
+
+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`)
+
+**Rationale:**
+- Go convention: camelCase for local variables
+- Readability: No visual clutter from underscores
+- Consistency: All generators follow same pattern
+- Human-like: Generated code looks hand-written
+
 ### Planned Features (Priority Order)
 
 1. `Result<T, E>` type (replaces `(T, error)`)

NESTED_MATCH_FIX_SUMMARY.md

@@ -0,0 +1,100 @@
+# Nested Match Block Fix - Implementation Summary
+
+## Status: PARTIAL - Core Fix Complete, Cleanup Logic Needs Refinement
+
+## What Was Fixed
+
+### Multi-Pass Processing (✅ Complete)
+- Modified `RustMatchProcessor.Process()` to run multiple passes (up to 10)
+- Each pass transforms one level of `match` expressions
+- Continues until no more `match` keywords remain
+- Successfully handles nested match blocks recursively
+
+### Test Results
+- New test `TestNestedMatchBlocks` passes ✅
+- Nested `match inner { ... }` is now transformed to nested switch statements
+- Previously: Nested match left untransformed, caused Lambda processor to incorrectly transform it
+- Now: All match keywords processed before Lambda processor runs
+
+## Remaining Issue
+
+### Invalid Block Expression Syntax
+When a match expression is inside a block expression (e.g., `Ok(inner) => { match inner { ... } }`), the transformation produces:
+
+```go
+result = {
+    // DINGO_MATCH_START: inner
+    scrutinee2 := inner
+    switch scrutinee2.tag { ... }
+}
+```
+
+This is **invalid Go syntax** - you cannot have `result = { switch ... }`.
+
+### Root Cause
+The Variable Hoisting pattern generates `result = expr` for match arms. When `expr` is a block `{ match ... }`, after transformation the block contains switch statements, not a valid expression.
+
+### Attempted Fix (Incomplete)
+Added `cleanupBlockExpressions()` to remove invalid `result = { switch ... }` patterns. However, the brace-counting logic is breaking the outer switch structure.
+
+## Recommended Next Steps
+
+### Option 1: Pre-Processing Block Detection
+Before multi-pass processing, detect blocks that contain ONLY a match expression:
+```dingo
+{ match inner { ... } }
+```
+
+Unwrap these to just:
+```dingo
+match inner { ... }
+```
+
+Then the multi-pass processing will handle them correctly without invalid block syntax.
+
+### Option 2: Smarter Assignment Context Detection
+In `generateCaseWithGuards()`, detect when the arm expression is a transformed match (contains `// DINGO_MATCH_START` marker) and handle it differently - don't wrap in `result = { ... }`, just execute the switch directly.
+
+### Option 3: Expression vs Statement Mode
+Add a parameter to `transformMatch()` indicating whether it's in expression context (needs `return`) or statement context (direct execution). Block expressions containing matches should use statement mode.
+
+## Files Modified
+
+- `pkg/preprocessor/rust_match.go`:
+  - Split `Process()` into `Process()` + `processSinglePass()`
+  - Added multi-pass loop with `containsMatchKeyword()` check
+  - Added `cleanupBlockExpressions()` (needs refinement)
+
+- `pkg/preprocessor/rust_match_nested_test.go`: New test file
+- `pkg/preprocessor/debug_nested_test.go`: Debug test file
+
+## Test Cases
+
+### Passing
+- `TestNestedMatchBlocks`: Verifies nested match is transformed
+
+### Needs Fix
+- `tests/golden/pattern_match_13_nested_blocks.dingo`: Produces invalid Go syntax
+
+## Performance Impact
+Minimal - most files complete in 1-2 passes. Complex nested matches might take 3-4 passes. Max 10 passes prevents infinite loops.
+
+## Verification Command
+
+```bash
+# Run unit test
+go test -v -run TestNestedMatchBlocks pkg/preprocessor
+
+# Test with actual file
+go run cmd/dingo/main.go build tests/golden/pattern_match_13_nested_blocks.dingo
+```
+
+## Summary for Main Chat
+
+Implemented multi-pass processing in RustMatch preprocessor to handle nested match blocks recursively. Each pass transforms one level of match expressions until no more `match` keywords remain (max 10 passes). Nested matches are now correctly transformed to nested switch statements before the Lambda processor runs, preventing the `func(None ...)` bug.
+
+Remaining work: Fix invalid `result = { switch ... }` syntax when match is inside a block expression. Recommend pre-processing to unwrap single-match blocks before multi-pass transformation.
+
+Files changed: 1 (rust_match.go)
+Tests added: 2 (rust_match_nested_test.go, debug_nested_test.go)
+Status: Core fix complete, cleanup needs refinement

ai-docs/fixes/null-coalesce-iife-indentation-fix.md

@@ -66,18 +66,20 @@ Example for chained coalescing:
 ```go
 // Before (multi-line):
 func() __INFER__ {
-	__coalesce0 := first
-	if __coalesce0.IsSome() {
-		return __coalesce0.Unwrap()
+	coalesce1 := first
+	if coalesce1.IsSome() {
+		return coalesce1.Unwrap()
 	}
 	// ... more checks
 	return last
 }()
 
 // After (single-line):
-func() __INFER__ { __coalesce0 := first; if __coalesce0.IsSome() { return __UNWRAP__(__coalesce0) }; __coalesce1 := second; if __coalesce1.IsSome() { return __UNWRAP__(__coalesce1) }; return last }()
+func() __INFER__ { coalesce1 := first; if coalesce1.IsSome() { return __UNWRAP__(coalesce1) }; coalesce2 := second; if coalesce2.IsSome() { return __UNWRAP__(coalesce2) }; return last }()
 ```
 
+**Note (2025-11-20)**: Updated examples to use new naming convention (`coalesce1` instead of `__coalesce0`). See `ai-docs/naming-convention-guide.md` for details.
+
 ### 3. Updated `__UNWRAP__` placeholder
 
 Changed from `.Unwrap()` method call to `__UNWRAP__()` placeholder for compatibility with enum-based Option types.