Claude Code transcript - page 1/1

title:	Channel array slices incompatible with direction-restricted params
state:	OPEN
author:	associate-1
labels:	
comments:	0
assignees:	
projects:	
milestone:	
number:	57
--
## Summary

When a proc parameter is a direction-annotated channel array (`[]CHAN BYTE in?`), the codegen generates a Go function signature with `[]<-chan byte`. However, callers passing a `[]chan byte` slice fail to compile because Go slices are not covariant — `[]chan byte` is not assignable to `[]<-chan byte`.

## Reproduction

Transpile `sort_pump.occ` with the course module:

```bash
./occam2go -I kroc/modules/course/libsrc -D TARGET.BITS.PER.WORD=32 -o /tmp/sort_pump.go kroc/modules/course/examples/sort_pump.occ
go vet /tmp/sort_pump.go
```

```
vet: /tmp/sort_pump.go:2899:32: cannot use mess (variable of type []chan byte) as []<-chan byte value in argument to screen_plex
```

## Root cause

The occam declaration:
```occam
PROC screen.plex (VAL INT n.inputs,  []CHAN BYTE in?,  CHAN BYTE out!)
```

Generates:
```go
func screen_plex(n_inputs int, in []<-chan byte, out chan<- byte)
```

The caller has:
```occam
[n.screen.inputs]CHAN BYTE mess:
...
screen.plex (n.screen.inputs, mess, out!)
```

Which generates:
```go
mess := make([]chan byte, n_screen_inputs)
// ...
screen_plex(n_screen_inputs, mess, out)  // ERROR: []chan byte ≠ []<-chan byte
```

In Go, individual channels are covariant (`chan T` assignable to `<-chan T`), but slices of channels are not (`[]chan T` is NOT assignable to `[]<-chan T`).

## Affected files

- `sort_pump.occ`
- `sort_pump_2.occ`
- Any program passing channel arrays to direction-restricted parameters

## Possible fixes

1. **Don't apply direction to channel array params** — generate `[]chan byte` instead of `[]<-chan byte` for `[]CHAN BYTE in?`. Simpler but loses Go's compile-time direction safety for channel arrays.
2. **Generate a conversion loop at call sites** — before calling the proc, create a `[]<-chan byte` wrapper slice from the `[]chan byte`, e.g.:
   ```go
   _tmp := make([]<-chan byte, len(mess))
   for i := range mess { _tmp[i] = mess[i] }
   screen_plex(n_screen_inputs, _tmp, out)
   ```

## Related

Tracking issue: #43

Entered plan mode. You should now focus on exploring the codebase and designing an implementation approach.

In plan mode, you should:
1. Thoroughly explore the codebase to understand existing patterns
2. Identify similar features and architectural approaches
3. Consider multiple approaches and their trade-offs
4. Use AskUserQuestion if you need to clarify the approach
5. Design a concrete implementation strategy
6. When ready, use ExitPlanMode to present your plan for approval

Remember: DO NOT write or edit any files yet. This is a read-only exploration and planning phase.

[
  {
    "type": "text",
    "text": "Excellent! I now have a comprehensive understanding of how channel arrays with direction annotations are handled. Let me compile my findings in a clear report.\n\n## Channel Array Parameters with Direction Annotations - Complete Walkthrough\n\nI've thoroughly analyzed the occam2go codebase and found exactly how channel array parameters with direction annotations are handled across the transpiler pipeline. Here are my findings with relevant code snippets and line numbers:\n\n---\n\n### 1. **AST Definition** (`/home/david/projects/code-associates/occam2go/ast/ast.go`, lines 144-154)\n\nThe `ProcParam` struct stores all necessary information:\n\n```go\ntype ProcParam struct {\n\tIsVal        bool   // VAL parameter (pass by value)\n\tType         string // INT, BYTE, BOOL, etc.\n\tName         string\n\tIsChan       bool   // true if this is a CHAN OF <type> parameter\n\tIsChanArray  bool   // true for []CHAN OF TYPE params\n\tIsOpenArray  bool   // true for []TYPE params (open array)\n\tChanElemType string // element type when IsChan (e.g., \"INT\")\n\tChanDir      string // \"?\" for input, \"!\" for output, \"\" for bidirectional\n\tArraySize    string // non-empty for fixed-size array params like [2]INT\n}\n```\n\n**Key fields:**\n- `IsChanArray`: Distinguishes `[]CHAN OF TYPE` from single `CHAN OF TYPE`\n- `ChanDir`: Stores direction as `\"?\"` (input/receive-only), `\"!\"` (output/send-only), or `\"\"` (bidirectional)\n- `ChanElemType`: The element type (e.g., `\"INT\"`)\n\n---\n\n### 2. **Parser - Direction Annotation Parsing** (`/home/david/projects/code-associates/occam2go/parser/parser.go`, lines 1988-2159)\n\nThe parser handles channel array direction in two locations:\n\n**Location A: Shared-type parameters** (lines 2023-2027)\n```go\n// Check for channel direction marker (? or !)\nif (param.IsChan || param.IsChanArray) && (p.peekTokenIs(lexer.RECEIVE) || p.peekTokenIs(lexer.SEND)) {\n\tp.nextToken()\n\tparam.ChanDir = p.curToken.Literal\n}\n```\n\n**Location B: Regular parameters** (lines 2142-2146)\n```go\n// Check for channel direction marker (? or !)\nif (param.IsChan || param.IsChanArray) && (p.peekTokenIs(lexer.RECEIVE) || p.peekTokenIs(lexer.SEND)) {\n\tp.nextToken()\n\tparam.ChanDir = p.curToken.Literal\n}\n```\n\n**Channel Array Parsing** (lines 2052-2084):\n```go\nif p.curTokenIs(lexer.LBRACKET) {\n\tif p.peekTokenIs(lexer.RBRACKET) {\n\t\t// Open array: []CHAN OF TYPE or []TYPE\n\t\tp.nextToken() // consume ]\n\t\tp.nextToken() // move past ]\n\t\tif p.curTokenIs(lexer.CHAN) {\n\t\t\t// []CHAN OF <type> or []CHAN <type> (channel array parameter)\n\t\t\tparam.IsChan = true\n\t\t\tparam.IsChanArray = true\n\t\t\tif p.peekTokenIs(lexer.OF) {\n\t\t\t\tp.nextToken() // consume OF\n\t\t\t}\n\t\t\tp.nextToken() // move to element type\n\t\t\tif isTypeToken(p.curToken.Type) || p.curTokenIs(lexer.IDENT) {\n\t\t\t\tparam.ChanElemType = p.curToken.Literal\n\t\t\t}\n\t\t\tp.nextToken()\n\t\t}\n\t\t// ... other open array handling\n\t}\n}\n```\n\n**Call-site direction handling** (lines 2181-2194):\nThe parser accepts but ignores direction annotations at the call site (e.g., `f(out!, in?)`):\n```go\n// Consume optional channel direction annotation at call site (e.g., out!)\nif p.peekTokenIs(lexer.SEND) || p.peekTokenIs(lexer.RECEIVE) {\n\tp.nextToken()\n}\n```\n\n---\n\n### 3. **Codegen - Signature Generation** (`/home/david/projects/code-associates/occam2go/codegen/codegen.go`, lines 2034-2073)\n\nThe `generateProcParams()` function builds the Go parameter list:\n\n```go\nfunc (g *Generator) generateProcParams(params []ast.ProcParam) string {\n\tvar parts []string\n\tfor _, p := range params {\n\t\tvar goType string\n\t\tif p.IsChanArray {\n\t\t\tgoType = \"[]\" + chanDirPrefix(p.ChanDir) + g.occamTypeToGo(p.ChanElemType)\n\t\t} else if p.IsChan {\n\t\t\tgoType = chanDirPrefix(p.ChanDir) + g.occamTypeToGo(p.ChanElemType)\n\t\t} else if p.IsOpenArray {\n\t\t\tgoType = \"[]\" + g.occamTypeToGo(p.Type)\n\t\t} else if p.ArraySize != \"\" {\n\t\t\t// Fixed-size array parameter: use slice for Go compatibility\n\t\t\tgoType = \"[]\" + g.occamTypeToGo(p.Type)\n\t\t} else {\n\t\t\tgoType = g.occamTypeToGo(p.Type)\n\t\t\tif !p.IsVal {\n\t\t\t\t// Non-VAL parameters are pass by reference in Occam\n\t\t\t\tgoType = \"*\" + goType\n\t\t\t}\n\t\t}\n\t\tpName := goIdent(p.Name)\n\t\tif renamed, ok := g.retypesRenames[p.Name]; ok {\n\t\t\tpName = renamed\n\t\t}\n\t\tparts = append(parts, fmt.Sprintf(\"%s %s\", pName, goType))\n\t}\n\treturn strings.Join(parts, \", \")\n}\n```\n\n**Key logic:**\n- For channel arrays: Builds as `\"[]\" + chanDirPrefix(dir) + elemType`\n- For single channels: Builds as `chanDirPrefix(dir) + elemType`\n- Direction prefix is applied BEFORE the element type\n\nThe helper function `chanDirPrefix()` (lines 2064-2073):\n```go\nfunc chanDirPrefix(dir string) string {\n\tswitch dir {\n\tcase \"?\":\n\t\treturn \"<-chan \" // input/receive-only\n\tcase \"!\":\n\t\treturn \"chan<- \" // output/send-only\n\tdefault:\n\t\treturn \"chan \" // bidirectional\n\t}\n}\n```\n\n---\n\n### 4. **Codegen - Proc Call Handling** (`/home/david/projects/code-associates/occam2go/codegen/codegen.go`, lines 2075-2115)\n\nThe `generateProcCall()` function determines if arguments need address-of (`&`):\n\n```go\nfunc (g *Generator) generateProcCall(call *ast.ProcCall) {\n\t// ... (handle built-in print, CAUSEERROR) ...\n\t\n\t// Look up procedure signature to determine which args need address-of\n\tparams := g.procSigs[call.Name]\n\n\tfor i, arg := range call.Args {\n\t\tif i > 0 {\n\t\t\tg.write(\", \")\n\t\t}\n\t\t// If this parameter is not VAL (i.e., pass by reference), take address\n\t\t// Channels, channel arrays, open arrays, and fixed-size arrays (mapped to slices) are already reference types\n\t\tif i < len(params) && !params[i].IsVal && !params[i].IsChan && !params[i].IsChanArray && !params[i].IsOpenArray && params[i].ArraySize == \"\" {\n\t\t\tg.write(\"&\")\n\t\t}\n\t\t// Wrap string literals with []byte() when passed to []BYTE parameters\n\t\tif _, isStr := arg.(*ast.StringLiteral); isStr && i < len(params) && params[i].IsOpenArray && params[i].Type == \"BYTE\" {\n\t\t\tg.write(\"[]byte(\")\n\t\t\tg.generateExpression(arg)\n\t\t\tg.write(\")\")\n\t\t} else {\n\t\t\tg.generateExpression(arg)\n\t\t}\n\t}\n\tg.write(\")\")\n\tg.write(\"\\n\")\n}\n```\n\n**Key insight:** Channel arrays (`IsChanArray=true`) are **reference types in Go** and do NOT get the address-of operator applied. They're passed directly.\n\n---\n\n### 5. **Tests**\n\n**Parser test** (`/home/david/projects/code-associates/occam2go/parser/parser_test.go`, lines 2146-2167):\n```go\nfunc TestChanArrayDirParam(t *testing.T) {\n\tinput := `PROC worker([]CHAN OF INT cs?)\n  SKIP\n`\n\t// ... parse and verify ...\n\tp0 := proc.Params[0]\n\tif !p0.IsChanArray {\n\t\tt.Error(\"param 0: expected IsChanArray=true\")\n\t}\n\tif p0.ChanDir != \"?\" {\n\t\tt.Errorf(\"param 0: expected ChanDir=?, got %q\", p0.ChanDir)\n\t}\n}\n```\n\n**Codegen test** (`/home/david/projects/code-associates/occam2go/codegen/codegen_test.go`, lines 617-629):\n```go\nfunc TestChanArrayDirParamGen(t *testing.T) {\n\tinput := `PROC worker([]CHAN OF INT cs?, []CHAN OF INT out!)\n  SKIP\n`\n\toutput := transpile(t, input)\n\n\tif !strings.Contains(output, \"cs []<-chan int\") {\n\t\tt.Errorf(\"expected '[]<-chan int' for input chan array, got:\\n%s\", output)\n\t}\n\tif !strings.Contains(output, \"out []chan<- int\") {\n\t\tt.Errorf(\"expected '[]chan<- int' for output chan array, got:\\n%s\", output)\n\t}\n}\n```\n\n**End-to-end test** (`/home/david/projects/code-associates/occam2go/codegen/e2e_concurrency_test.go`, lines 229-250):\nTests actual runtime behavior with direction-restricted channel parameters.\n\n---\n\n## Summary\n\n| Stage | File | Lines | What Happens |\n|-------|------|-------|--------------|\n| **AST** | `ast/ast.go` | 144-154 | `ProcParam` struct with `IsChanArray`, `ChanDir`, `ChanElemType` |\n| **Parser** | `parser/parser.go` | 2052-2084 | Parse `[]CHAN OF TYPE` and set `IsChanArray=true` |\n| **Parser** | `parser/parser.go` | 2023-2027, 2142-2146 | After parsing channel array, check for `?` or `!` and store in `ChanDir` |\n| **Codegen** | `codegen/codegen.go` | 2038-2039 | For channel arrays: emit `\"[]\" + chanDirPrefix(ChanDir) + elemType` |\n| **Codegen** | `codegen/codegen.go` | 2064-2073 | `chanDirPrefix()` converts `\"?\"` → `\"<-chan \"`, `\"!\"` → `\"chan<- \"` |\n| **Codegen** | `codegen/codegen.go` | 2101 | At call site, channel arrays are treated as reference types (no `&`) |\n\nThe transpiler correctly handles channel array direction annotations by:\n1. Parsing `[]CHAN OF TYPE dir` in the parser\n2. Storing the direction in `ChanDir`\n3. Generating the correct Go type signature: `[]<-chan int` or `[]chan<- int`\n4. Passing arrays without address-of operator since they're reference types"
  },
  {
    "type": "text",
    "text": "agentId: a7c5e5b3c076c2ebe (for resuming to continue this agent's work if needed)\n<usage>total_tokens: 44894\ntool_uses: 13\nduration_ms: 44153</usage>"
  }
]

[
  {
    "type": "text",
    "text": "Now I have all the information I need. Let me synthesize my analysis.\n\n---\n\n## Analysis of Both Approaches\n\n### Approach 1: Drop direction from channel array params\n\n**Change**: In `generateProcParams`, when `p.IsChanArray` is true, always emit `\"[]chan \" + goType` regardless of `p.ChanDir`.\n\n**Pros**:\n- Extremely simple: a single line change in `generateProcParams` (line 2039)\n- No changes needed at call sites (`generateProcCall`, `generateFuncCallExpr`)\n- No new temp variables, no code bloat\n- Works for all cases: callers always have `[]chan T` from declarations, so `[]chan T` -> `[]chan T` always works\n\n**Cons**:\n- Loses compile-time direction safety on channel arrays. A proc with `[]CHAN OF INT in?` could accidentally send on `in[i]`, and Go would not catch it at compile time.\n- However, this loss is quite minor for a transpiler: the occam compiler would have already verified direction safety before the code reaches the transpiler.\n\n**Edge cases**:\n- When a proc receives `[]<-chan int` and passes it to another proc also expecting `[]<-chan int`: With this approach both become `[]chan int`, so it works trivially.\n- When a proc receives `[]chan int` (bidirectional) and passes to `[]CHAN INT in?`: Both are `[]chan int`, works fine.\n\n### Approach 2: Generate conversion loop at call sites\n\n**Change**: In `generateProcCall` (and `generateFuncCallExpr`), detect when parameter `i` is `IsChanArray` with a non-empty `ChanDir`, and the argument is a `[]chan T`. Generate a temporary variable with a conversion loop.\n\n**Pros**:\n- Preserves compile-time direction safety in the generated Go code\n- The generated Go code would look \"idiomatic\" in the sense that the function signature accurately documents intent\n\n**Cons**:\n- Significantly more complex:\n  - Need to emit multi-line preamble code before the proc call (conversion loops)\n  - The current call generation is inline (within a single `g.write(\"(\")...g.write(\")\")` sequence), so conversion loops would need to be emitted before the call line\n  - Need unique temp variable names (use `tmpCounter`)\n  - Need to handle the case where the argument is NOT a simple identifier (e.g., a slice expression)\n  - Need to determine the argument's channel directionality to know if conversion is needed\n  - Need to handle nested calls where a proc already has `[]<-chan T` and passes it on (no conversion needed)\n- The codegen does NOT have type information for local variables; it only tracks `procSigs`, `refParams`, `boolVars`, `recordVars`, `chanProtocols`. It does NOT know whether a given identifier is `[]chan int` or `[]<-chan int`. This is a fundamental gap.\n- Without type tracking, the codegen would have to assume all channel array args need conversion, which would generate unnecessary conversion loops when the types already match (e.g., proc A receives `[]<-chan int in` and passes it to proc B also expecting `[]<-chan int`)\n- Or: it would need a new tracking map (e.g., `chanArrayDirs map[string]string`) mapping variable names to their direction, which adds even more complexity.\n\n### Key Insight: The codegen has no type inference system\n\nThe codegen currently operates without tracking variable types beyond a few special cases (`boolVars`, `recordVars`, `chanProtocols`, `refParams`). It has no general type system. Adding proper type tracking for channel arrays to know \"is this argument already `[]<-chan T`?\" would be a disproportionately large change for this feature.\n\n### Recommendation: Approach 1 (Drop direction from channel array params)\n\nThe key argument is pragmatic:\n\n1. **Occam already enforces direction safety**. The occam compiler (or the source author) ensures that input channels are only read from and output channels are only written to. The transpiler does not need to re-enforce this in Go.\n\n2. **Single channels still get direction safety**. A `CHAN OF INT c?` parameter still becomes `<-chan int` in Go, and `chan int` is assignable to `<-chan int` as a single value. Only the array case has this issue.\n\n3. **The Go standard library and ecosystem commonly use `[]chan T`** for channel arrays. Direction-restricted slices are rare because of exactly this covariance problem.\n\n4. **Minimal code change, minimal risk of regression**. A single-line change plus a test update.\n\n5. **The alternative is disproportionately complex** for what amounts to defense-in-depth on generated code.\n\n---\n\n## Concrete Implementation Plan\n\n### Step 1: Modify `generateProcParams` in `codegen/codegen.go` (line 2039)\n\nCurrent code:\n```go\nif p.IsChanArray {\n    goType = \"[]\" + chanDirPrefix(p.ChanDir) + g.occamTypeToGo(p.ChanElemType)\n}\n```\n\nChange to:\n```go\nif p.IsChanArray {\n    goType = \"[]chan \" + g.occamTypeToGo(p.ChanElemType)\n}\n```\n\nThis removes the `chanDirPrefix` call for channel array params, always generating `[]chan T` regardless of the direction annotation. The `chanDirPrefix` function is still used for single channel params (`p.IsChan` on line 2041) and remains unchanged.\n\n### Step 2: Update `TestChanArrayDirParamGen` in `codegen/codegen_test.go` (lines 617-629)\n\nThe existing test asserts that `[]CHAN OF INT cs?` generates `[]<-chan int` and `[]CHAN OF INT out!` generates `[]chan<- int`. Update the assertions to expect `[]chan int` for both:\n\n```go\nfunc TestChanArrayDirParamGen(t *testing.T) {\n    input := `PROC worker([]CHAN OF INT cs?, []CHAN OF INT out!)\n  SKIP\n`\n    output := transpile(t, input)\n\n    if !strings.Contains(output, \"cs []chan int\") {\n        t.Errorf(\"expected '[]chan int' for input chan array, got:\\n%s\", output)\n    }\n    if !strings.Contains(output, \"out []chan int\") {\n        t.Errorf(\"expected '[]chan int' for output chan array, got:\\n%s\", output)\n    }\n}\n```\n\n### Step 3: Add e2e test in `codegen/e2e_array_test.go`\n\nAdd a new test `TestE2E_ChanArrayDirParam` that declares a `[n]CHAN OF INT` array, then passes it to a proc with `[]CHAN OF INT in?` and `[]CHAN OF INT out!` params. This tests that the transpiled code compiles and runs correctly.\n\n```go\nfunc TestE2E_ChanArrayDirParam(t *testing.T) {\n    // Pass []chan int to a proc with direction-annotated []CHAN params\n    occam := `PROC sender([]CHAN OF INT out!, VAL INT n)\n  SEQ i = 0 FOR n\n    out[i] ! (i + 1) * 10\n\nPROC receiver([]CHAN OF INT in?, VAL INT n, INT sum)\n  SEQ\n    sum := 0\n    SEQ i = 0 FOR n\n      INT x:\n      in[i] ? x\n      sum := sum + x\n\nSEQ\n  [3]CHAN OF INT cs:\n  INT total:\n  total := 0\n  PAR\n    sender(cs, 3)\n    receiver(cs, 3, total)\n  print.int(total)\n`\n    output := transpileCompileRun(t, occam)\n    expected := \"60\\n\"\n    if output != expected {\n        t.Errorf(\"expected %q, got %q\", expected, output)\n    }\n}\n```\n\n### Step 4: Verify course module still compiles\n\nRun the course module transpilation and `go vet` to ensure no regression:\n```bash\n./occam2go -I kroc/modules/course/libsrc -D TARGET.BITS.PER.WORD=32 -o /tmp/course_out.go kroc/modules/course/libsrc/course.module\ngo vet /tmp/course_out.go\n```\n\n### Step 5: Update documentation\n\nUpdate `CLAUDE.md` table entry for channel arrays. The current entry says:\n```\n| `PROC f([]CHAN OF INT cs)` | `func f(cs []chan int)` |\n```\n\nAdd a note clarifying that direction annotations on channel array params are intentionally dropped:\n```\n| `PROC f([]CHAN OF INT cs?)` | `func f(cs []chan int)` (direction dropped for Go slice compatibility) |\n```\n\n### Files Changed Summary\n\n| File | Change |\n|------|--------|\n| `codegen/codegen.go` line 2039 | Replace `chanDirPrefix(p.ChanDir)` with `\"chan \"` for `IsChanArray` |\n| `codegen/codegen_test.go` lines 617-629 | Update assertions in `TestChanArrayDirParamGen` |\n| `codegen/e2e_array_test.go` | Add new `TestE2E_ChanArrayDirParam` test |\n| `CLAUDE.md` | Update mapping table |\n\n### Critical Files for Implementation\n- `/home/david/projects/code-associates/occam2go/codegen/codegen.go` - Single-line fix at line 2039 in `generateProcParams` to drop direction prefix for channel array params\n- `/home/david/projects/code-associates/occam2go/codegen/codegen_test.go` - Update `TestChanArrayDirParamGen` assertions (lines 617-629) to expect `[]chan int` instead of directional types\n- `/home/david/projects/code-associates/occam2go/codegen/e2e_array_test.go` - Add new e2e test `TestE2E_ChanArrayDirParam` proving the fix compiles and runs\n- `/home/david/projects/code-associates/occam2go/CLAUDE.md` - Update the occam-to-Go mapping table to document the direction-dropping behavior"
  },
  {
    "type": "text",
    "text": "agentId: a8554b10112d4e419 (for resuming to continue this agent's work if needed)\n<usage>total_tokens: 56754\ntool_uses: 34\nduration_ms: 165359</usage>"
  }
]

  2030→	g.boolVars = oldBoolVars
  2031→	g.retypesRenames = oldRenames
  2032→}
  2033→
  2034→func (g *Generator) generateProcParams(params []ast.ProcParam) string {
  2035→	var parts []string
  2036→	for _, p := range params {
  2037→		var goType string
  2038→		if p.IsChanArray {
  2039→			goType = "[]" + chanDirPrefix(p.ChanDir) + g.occamTypeToGo(p.ChanElemType)
  2040→		} else if p.IsChan {
  2041→			goType = chanDirPrefix(p.ChanDir) + g.occamTypeToGo(p.ChanElemType)
  2042→		} else if p.IsOpenArray {
  2043→			goType = "[]" + g.occamTypeToGo(p.Type)
  2044→		} else if p.ArraySize != "" {
  2045→			// Fixed-size array parameter: use slice for Go compatibility
  2046→			// (occam [n]TYPE and []TYPE both map to Go slices)
  2047→			goType = "[]" + g.occamTypeToGo(p.Type)
  2048→		} else {
  2049→			goType = g.occamTypeToGo(p.Type)
  2050→			if !p.IsVal {
  2051→				// Non-VAL parameters are pass by reference in Occam
  2052→				goType = "*" + goType
  2053→			}
  2054→		}
  2055→		pName := goIdent(p.Name)
  2056→		if renamed, ok := g.retypesRenames[p.Name]; ok {
  2057→			pName = renamed
  2058→		}
  2059→		parts = append(parts, fmt.Sprintf("%s %s", pName, goType))
  2060→	}
  2061→	return strings.Join(parts, ", ")
  2062→}
  2063→
  2064→func chanDirPrefix(dir string) string {
  2065→	switch dir {
  2066→	case "?":
  2067→		return "<-chan " // input/receive-only
  2068→	case "!":
  2069→		return "chan<- " // output/send-only
  2070→	default:
  2071→		return "chan " // bidirectional
  2072→	}
  2073→}
  2074→
  2075→func (g *Generator) generateProcCall(call *ast.ProcCall) {
  2076→	// Handle built-in print procedures
  2077→	if printBuiltins[call.Name] {
  2078→		g.generatePrintCall(call)
  2079→		return

   612→	if !strings.Contains(output, "func worker(input <-chan int, output chan<- int)") {
   613→		t.Errorf("expected directed channel types in output, got:\n%s", output)
   614→	}
   615→}
   616→
   617→func TestChanArrayDirParamGen(t *testing.T) {
   618→	input := `PROC worker([]CHAN OF INT cs?, []CHAN OF INT out!)
   619→  SKIP
   620→`
   621→	output := transpile(t, input)
   622→
   623→	if !strings.Contains(output, "cs []<-chan int") {
   624→		t.Errorf("expected '[]<-chan int' for input chan array, got:\n%s", output)
   625→	}
   626→	if !strings.Contains(output, "out []chan<- int") {
   627→		t.Errorf("expected '[]chan<- int' for output chan array, got:\n%s", output)
   628→	}
   629→}
   630→
   631→func TestRecordFieldAccessCodegen(t *testing.T) {
   632→	input := `RECORD POINT
   633→  INT x:
   634→  INT y:
   635→SEQ
   636→  POINT p:

codegen/e2e_array_test.go:75:func TestE2E_ChanArrayBasic(t *testing.T) {
codegen/e2e_array_test.go:97:func TestE2E_ChanArrayWithProc(t *testing.T) {
codegen/e2e_array_test.go:122:func TestE2E_ChanArrayAlt(t *testing.T) {

    97→func TestE2E_ChanArrayWithProc(t *testing.T) {
    98→	// Pass channel array to a PROC
    99→	occam := `PROC sender([]CHAN OF INT cs, VAL INT n)
   100→  SEQ i = 0 FOR n
   101→    cs[i] ! (i + 1) * 100
   102→
   103→SEQ
   104→  [3]CHAN OF INT cs:
   105→  INT sum:
   106→  sum := 0
   107→  PAR
   108→    sender(cs, 3)
   109→    SEQ i = 0 FOR 3
   110→      INT x:
   111→      cs[i] ? x
   112→      sum := sum + x
   113→  print.int(sum)
   114→`
   115→	output := transpileCompileRun(t, occam)
   116→	expected := "600\n"
   117→	if output != expected {
   118→		t.Errorf("expected %q, got %q", expected, output)
   119→	}
   120→}
   121→
   122→func TestE2E_ChanArrayAlt(t *testing.T) {
   123→	// Use channel array in ALT
   124→	occam := `SEQ
   125→  [2]CHAN OF INT cs:
   126→  INT result:
   127→  result := 0
   128→  PAR
   129→    cs[0] ! 42
   130→    ALT
   131→      cs[0] ? result
   132→        print.int(result)
   133→      cs[1] ? result
   134→        print.int(result)
   135→`
   136→	output := transpileCompileRun(t, occam)

File created successfully at: /home/david/.claude/plans/wild-hopping-avalanche.md