Claude Code transcript - page 1/2

title:	Support protocol declaration trailing colon terminator
state:	OPEN
author:	associate-1
labels:	
comments:	0
assignees:	
projects:	
milestone:	
number:	73
--
## Description

The occam2 language allows an optional trailing `:` on protocol declarations. The transpiler currently does not consume this colon, causing parse errors.

## Occam2 syntax

```occam
PROTOCOL STATE IS BOOL :
PROTOCOL RESPONSE IS BOOL; BOOL :
PROTOCOL COMMAND
  CASE
    set.state; BOOL
    evolve
    terminate
:
```

All three protocol forms (simple, sequential, and variant) can have a trailing colon terminator.

## Current behavior

```
unexpected token: :
```

## Expected behavior

The trailing `:` should be consumed and ignored, just as it is for PROC and FUNCTION declarations (already supported per CLAUDE.md: "KRoC-style colon terminators on PROC/FUNCTION (optional)").

## Scope

Parser only — add colon consumption at the end of `parseProtocolDecl()` for both the `IS` form and the variant `CASE` form.

## Context

Found in `historical-examples/life.occ` (PR #71) at lines 26, 36, 38. Cascade errors from this appear at lines 47, 74, 117, 233, 325, 383.

title:	Support CASE with comma-separated match values and ELSE
state:	OPEN
author:	associate-1
labels:	
comments:	0
assignees:	
projects:	
milestone:	
number:	75
--
## Description

Occam2 CASE statements allow multiple match values per arm (comma-separated) and an ELSE clause for the default case. The transpiler currently only parses a single value per CASE arm and does not handle ELSE.

## Occam2 syntax

```occam
CASE char
  'q', 'Q'
    activity := terminated
  's', 'S'
    activity := idle
  ELSE
    activity := single.step

CASE activity
  free.running, single.step
    BOOL changing :
    SEQ
      ...
```

## Expected Go output

```go
switch char {
case 'q', 'Q':
    activity = terminated
case 's', 'S':
    activity = idle
default:
    activity = single_step
}

switch activity {
case free_running, single_step:
    ...
}
```

## Current behavior

```
unexpected token: ,
unexpected token: BYTE_LIT
unexpected token: ELSE
```

Note: the ELSE errors are cascade failures from the comma parsing — CASE ELSE may already work in isolation but needs verification.

## Scope

Primarily parser — the AST's `CaseChoice.Values` is already a `[]Expression` slice, so it was designed for multiple values. The parser's `parseCaseStatement()` just needs to loop on commas. ELSE support may need a small addition if not already present.

Codegen should already handle multiple values in `CaseChoice.Values` since Go `switch` natively supports `case a, b:`.

## Context

Found in `historical-examples/life.occ` (PR #71) at lines 179, 181, 183, 185, 316, 321, 369.

title:	Support parenthesized guard expressions in ALT
state:	OPEN
author:	associate-1
labels:	
comments:	0
assignees:	
projects:	
milestone:	
number:	78
--
## Description

ALT guards in occam2 can be arbitrary boolean expressions, including parenthesized ones. The transpiler currently only accepts `IDENT`, `TRUE`, or `FALSE` as the first token in an ALT guard expression.

## Occam2 syntax

```occam
ALT
  (activity <> editing) & keyboard ? char
    activity := new.activity(char)
  (activity <> idle) & SKIP
    ...
```

## Current behavior

```
expected channel name or guard in ALT case, got (
```

The parser rejects the opening `(` because `parseAltCase()` only looks for identifiers, `TRUE`, or `FALSE` at the start of a case.

## Expected behavior

The parser should accept any valid boolean expression (including parenthesized expressions) as an ALT guard. The expression parsing should continue until `&` is encountered, then parse the channel operation or SKIP that follows.

## Scope

Parser only — extend `parseAltCase()` to use `parseExpression()` for the guard, rather than only accepting simple tokens.

## Context

Found in `historical-examples/life.occ` (PR #71) at lines 361, 363.

title:	Support multi-line abbreviations (IS as line continuation)
state:	OPEN
author:	associate-1
labels:	
comments:	0
assignees:	
projects:	
milestone:	
number:	79
--
## Description

When an abbreviation's `IS` keyword appears at the end of a line, the expression value on the next line should be treated as a continuation. Currently the lexer emits NEWLINE/INDENT tokens, causing parse errors.

## Occam2 syntax

```occam
VAL [neighbours]INT nx IS
      [ right, x,    left, left, left, x,  right, right ] :
VAL [neighbours]INT ny IS
      [ down,  down, down, y,    up,   up, up,    y     ] :
```

## Expected Go output

```go
nx := []int{right, x, left, left, left, x, right, right}
ny := []int{down, down, down, y, up, up, up, y}
```

## Current behavior

```
unexpected token in expression: NEWLINE
expected :, got INDENT
```

The lexer's `isContinuationOp()` does not include `IS`, so NEWLINE/INDENT tokens are emitted between `IS` and the value expression.

## Scope

Lexer only — add `IS` to the continuation logic so that NEWLINE/INDENT/DEDENT are suppressed when `IS` appears at end of line. Since `IS` is not a binary operator but an abbreviation keyword, the approach may need to check `lastTokenType == IS` rather than adding it to `isContinuationOp()` directly.

## Context

Found in `historical-examples/life.occ` (PR #71) at lines 411-414.

[
  {
    "type": "text",
    "text": "Perfect! I have found all the relevant code. Here's the comprehensive answer:\n\n## `isContinuationOp` Function (Lines 415-429)\n\n```go\n// isContinuationOp returns true if the given token type, when appearing at the\n// end of a line, indicates that the expression continues on the next line.\n// This causes NEWLINE and INDENT/DEDENT suppression on the continuation line.\nfunc isContinuationOp(t TokenType) bool {\n\tswitch t {\n\tcase AND, OR,\n\t\tPLUS, MINUS, MULTIPLY, DIVIDE, MODULO,\n\t\tPLUS_KW, MINUS_KW, TIMES,\n\t\tEQ, NEQ, LT, GT, LE, GE,\n\t\tBITAND, BITOR, BITXOR, LSHIFT, RSHIFT,\n\t\tASSIGN, AFTER:\n\t\treturn true\n\t}\n\treturn false\n}\n```\n\nThis function checks if a token type represents a binary operator or assignment that should allow continuation to the next line.\n\n## `lastTokenType` Field (Lines 23-26)\n\n```go\n// Last real token type for continuation detection.\n// When the last token is a binary operator or :=, NEWLINE and INDENT/DEDENT\n// are suppressed on the next line (multi-line expression continuation).\nlastTokenType TokenType\n```\n\nThe field is declared in the `Lexer` struct at line 26.\n\n## Usage of `isContinuationOp` - Call Sites\n\n### 1. **Line 82** - During indentation processing at line start:\n```go\nif l.parenDepth > 0 || isContinuationOp(l.lastTokenType) {\n\t// Inside parentheses/brackets or after a continuation operator:\n\t// suppress INDENT/DEDENT tokens\n\t// (don't modify indentStack — resume normal tracking after)\n}\n```\n\n### 2. **Line 239** - When encountering newline character:\n```go\nif l.parenDepth > 0 || isContinuationOp(l.lastTokenType) {\n\t// Inside parentheses/brackets or after a continuation operator:\n\t// suppress NEWLINE, get next real token\n\treturn l.NextToken()\n}\n```\n\n## `lastTokenType` Usage (Lines 59-65)\n\nThe field is updated in `NextToken()`:\n```go\nfunc (l *Lexer) NextToken() Token {\n\ttok := l.nextTokenInner()\n\t// Track last real token type for continuation detection\n\tif tok.Type != NEWLINE && tok.Type != INDENT && tok.Type != DEDENT && tok.Type != EOF {\n\t\tl.lastTokenType = tok.Type\n\t}\n\treturn tok\n}\n```\n\nThis ensures `lastTokenType` always holds the most recent \"real\" token (excluding structural tokens like NEWLINE, INDENT, DEDENT, EOF), which is then used to determine if the next line should suppress these tokens for continuation expressions."
  },
  {
    "type": "text",
    "text": "agentId: ad226273f26d550d0 (for resuming to continue this agent's work if needed)\n<usage>total_tokens: 23515\ntool_uses: 1\nduration_ms: 7333</usage>"
  }
]

[
  {
    "type": "text",
    "text": "Perfect! Now I have all the information. Let me compile the complete response with the function implementations and the CaseChoice struct definition.\n\n## Complete Function Implementations and Struct Definition\n\n### 1. `parseProtocolDecl` (lines 844-912)\n\n```go\nfunc (p *Parser) parseProtocolDecl() *ast.ProtocolDecl {\n\tdecl := &ast.ProtocolDecl{Token: p.curToken}\n\n\t// Expect protocol name\n\tif !p.expectPeek(lexer.IDENT) {\n\t\treturn nil\n\t}\n\tdecl.Name = p.curToken.Literal\n\n\t// Check if this is IS form (simple/sequential) or CASE form (variant)\n\tif p.peekTokenIs(lexer.NEWLINE) || p.peekTokenIs(lexer.INDENT) {\n\t\t// Could be variant: PROTOCOL NAME \\n INDENT CASE ...\n\t\t// Skip newlines\n\t\tfor p.peekTokenIs(lexer.NEWLINE) {\n\t\t\tp.nextToken()\n\t\t}\n\n\t\tif p.peekTokenIs(lexer.INDENT) {\n\t\t\tp.nextToken() // consume INDENT\n\t\t\tp.nextToken() // move into block\n\n\t\t\tif p.curTokenIs(lexer.CASE) {\n\t\t\t\t// Variant protocol\n\t\t\t\tdecl.Kind = \"variant\"\n\t\t\t\tdecl.Variants = p.parseProtocolVariants()\n\t\t\t\tp.protocolNames[decl.Name] = true\n\t\t\t\tp.protocolDefs[decl.Name] = decl\n\t\t\t\treturn decl\n\t\t\t}\n\t\t}\n\n\t\tp.addError(\"expected IS or CASE in protocol declaration\")\n\t\treturn nil\n\t}\n\n\t// IS form: PROTOCOL NAME IS TYPE [; TYPE]*\n\tif !p.expectPeek(lexer.IS) {\n\t\treturn nil\n\t}\n\n\t// Parse type list\n\tp.nextToken()\n\ttypeName := p.parseProtocolTypeName()\n\tif typeName == \"\" {\n\t\treturn nil\n\t}\n\tdecl.Types = append(decl.Types, typeName)\n\n\t// Check for sequential: ; TYPE\n\tfor p.peekTokenIs(lexer.SEMICOLON) {\n\t\tp.nextToken() // move to ;\n\t\tp.nextToken() // move past ;\n\t\ttypeName = p.parseProtocolTypeName()\n\t\tif typeName == \"\" {\n\t\t\treturn nil\n\t\t}\n\t\tdecl.Types = append(decl.Types, typeName)\n\t}\n\n\tif len(decl.Types) == 1 {\n\t\tdecl.Kind = \"simple\"\n\t} else {\n\t\tdecl.Kind = \"sequential\"\n\t}\n\n\tp.protocolNames[decl.Name] = true\n\tp.protocolDefs[decl.Name] = decl\n\treturn decl\n}\n```\n\n### 2. `parseCaseStatement` (lines 2579-2661)\n\n```go\nfunc (p *Parser) parseCaseStatement() *ast.CaseStatement {\n\tstmt := &ast.CaseStatement{Token: p.curToken}\n\n\t// Parse selector expression on the same line\n\tp.nextToken()\n\tstmt.Selector = p.parseExpression(LOWEST)\n\n\t// Skip to next line\n\tfor p.peekTokenIs(lexer.NEWLINE) {\n\t\tp.nextToken()\n\t}\n\n\t// Expect INDENT\n\tif !p.peekTokenIs(lexer.INDENT) {\n\t\tp.addError(\"expected indented block after CASE\")\n\t\treturn stmt\n\t}\n\tp.nextToken() // consume INDENT\n\tstartLevel := p.indentLevel\n\tp.nextToken() // move into block\n\n\t// Parse case choices\n\tfor !p.curTokenIs(lexer.EOF) {\n\t\t// Skip newlines\n\t\tfor p.curTokenIs(lexer.NEWLINE) {\n\t\t\tp.nextToken()\n\t\t}\n\n\t\t// Handle DEDENT tokens\n\t\tfor p.curTokenIs(lexer.DEDENT) {\n\t\t\tif p.indentLevel < startLevel {\n\t\t\t\treturn stmt\n\t\t\t}\n\t\t\tp.nextToken()\n\t\t}\n\n\t\t// Skip any more newlines after DEDENT\n\t\tfor p.curTokenIs(lexer.NEWLINE) {\n\t\t\tp.nextToken()\n\t\t}\n\n\t\tif p.curTokenIs(lexer.EOF) {\n\t\t\tbreak\n\t\t}\n\n\t\tif p.indentLevel < startLevel {\n\t\t\tbreak\n\t\t}\n\n\t\t// Safety guard: record position before parsing to detect no-progress\n\t\tprevToken := p.curToken\n\t\tprevPeek := p.peekToken\n\n\t\tchoice := ast.CaseChoice{}\n\n\t\tif p.curTokenIs(lexer.ELSE) {\n\t\t\tchoice.IsElse = true\n\t\t} else {\n\t\t\t// Parse value expression\n\t\t\tchoice.Values = append(choice.Values, p.parseExpression(LOWEST))\n\t\t}\n\n\t\t// Skip newlines and expect INDENT for body\n\t\tfor p.peekTokenIs(lexer.NEWLINE) {\n\t\t\tp.nextToken()\n\t\t}\n\n\t\tif p.peekTokenIs(lexer.INDENT) {\n\t\t\tp.nextToken() // consume INDENT\n\t\t\tp.nextToken() // move to body\n\t\t\tchoice.Body = p.parseBodyStatements()\n\t\t}\n\n\t\tstmt.Choices = append(stmt.Choices, choice)\n\n\t\t// No-progress guard: if we haven't moved, break to prevent infinite loop\n\t\tif p.curToken == prevToken && p.peekToken == prevPeek {\n\t\t\tbreak\n\t\t}\n\t}\n\n\treturn stmt\n}\n```\n\n### 3. `parseAltCase` (lines 1665-1792)\n\n```go\nfunc (p *Parser) parseAltCase() *ast.AltCase {\n\taltCase := &ast.AltCase{}\n\n\t// Parse scoped declarations before the channel input (e.g., BYTE ch:, VAL INT X IS expr:)\n\tfor p.isAltDeclStart() {\n\t\tstmt := p.parseStatement()\n\t\tif stmt != nil {\n\t\t\taltCase.Declarations = append(altCase.Declarations, stmt)\n\t\t}\n\t\t// Advance past the end of the declaration\n\t\tif !p.curTokenIs(lexer.NEWLINE) && !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {\n\t\t\tp.nextToken()\n\t\t}\n\t\t// Skip newlines to reach next token\n\t\tfor p.curTokenIs(lexer.NEWLINE) {\n\t\t\tp.nextToken()\n\t\t}\n\t}\n\n\t// Check for guard: expression & channel ? var\n\t// For now, we expect: channel ? var (no guard support yet)\n\t// or: guard & channel ? var\n\n\t// First token should be identifier (channel name or guard start)\n\tif !p.curTokenIs(lexer.IDENT) && !p.curTokenIs(lexer.TRUE) && !p.curTokenIs(lexer.FALSE) {\n\t\tp.addError(fmt.Sprintf(\"expected channel name or guard in ALT case, got %s\", p.curToken.Type))\n\t\treturn nil\n\t}\n\n\t// Look ahead to determine if this is a guard or channel\n\t// If next token is & then we have a guard\n\t// If next token is ? then it's a channel/timer receive\n\tif p.peekTokenIs(lexer.RECEIVE) {\n\t\tname := p.curToken.Literal\n\t\tif p.timerNames[name] {\n\t\t\t// Timer case: tim ? AFTER deadline\n\t\t\taltCase.IsTimer = true\n\t\t\taltCase.Timer = name\n\t\t\tp.nextToken() // move to ?\n\t\t\tif !p.expectPeek(lexer.AFTER) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\tp.nextToken() // move past AFTER\n\t\t\taltCase.Deadline = p.parseExpression(LOWEST)\n\t\t} else {\n\t\t\t// Simple case: channel ? var\n\t\t\taltCase.Channel = name\n\t\t\tp.nextToken() // move to ?\n\t\t\tif !p.expectPeek(lexer.IDENT) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\taltCase.Variable = p.curToken.Literal\n\t\t}\n\t} else if p.peekTokenIs(lexer.LBRACKET) {\n\t\t// Indexed channel case: cs[i] ? var\n\t\tname := p.curToken.Literal\n\t\taltCase.Channel = name\n\t\tp.nextToken() // move to [\n\t\tp.nextToken() // move past [\n\t\taltCase.ChannelIndex = p.parseExpression(LOWEST)\n\t\tif !p.expectPeek(lexer.RBRACKET) {\n\t\t\treturn nil\n\t\t}\n\t\tif !p.expectPeek(lexer.RECEIVE) {\n\t\t\treturn nil\n\t\t}\n\t\tif !p.expectPeek(lexer.IDENT) {\n\t\t\treturn nil\n\t\t}\n\t\taltCase.Variable = p.curToken.Literal\n\t} else {\n\t\t// Could be a guard followed by & channel ? var\n\t\t// For simplicity, parse expression until we hit &\n\t\t// For now, only support simple TRUE/FALSE or identifier guards\n\t\tguard := p.parseExpression(LOWEST)\n\t\taltCase.Guard = guard\n\n\t\t// Expect &\n\t\tif !p.peekTokenIs(lexer.AMPERSAND) {\n\t\t\tp.addError(\"expected & after guard in ALT case\")\n\t\t\treturn nil\n\t\t}\n\t\tp.nextToken() // move to &\n\t\tp.nextToken() // move past &\n\n\t\t// Now expect channel ? var or channel[index] ? var\n\t\tif !p.curTokenIs(lexer.IDENT) {\n\t\t\tp.addError(fmt.Sprintf(\"expected channel name after guard, got %s\", p.curToken.Type))\n\t\t\treturn nil\n\t\t}\n\t\taltCase.Channel = p.curToken.Literal\n\n\t\tif p.peekTokenIs(lexer.LBRACKET) {\n\t\t\t// Indexed channel with guard: guard & cs[i] ? var\n\t\t\tp.nextToken() // move to [\n\t\t\tp.nextToken() // move past [\n\t\t\taltCase.ChannelIndex = p.parseExpression(LOWEST)\n\t\t\tif !p.expectPeek(lexer.RBRACKET) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\n\t\tif !p.expectPeek(lexer.RECEIVE) {\n\t\t\treturn nil\n\t\t}\n\t\tif !p.expectPeek(lexer.IDENT) {\n\t\t\treturn nil\n\t\t}\n\t\taltCase.Variable = p.curToken.Literal\n\t}\n\n\t// Skip to next line for the body\n\tfor p.peekTokenIs(lexer.NEWLINE) {\n\t\tp.nextToken()\n\t}\n\n\t// Expect INDENT for body\n\tif !p.peekTokenIs(lexer.INDENT) {\n\t\tp.addError(\"expected indented body after ALT case\")\n\t\treturn altCase\n\t}\n\tp.nextToken() // consume INDENT\n\tp.nextToken() // move into body\n\n\taltCase.Body = p.parseBodyStatements()\n\n\treturn altCase\n}\n```\n\n### 4. `CaseChoice` Struct Definition (lines 222-226 in ast/ast.go)\n\n```go\ntype CaseChoice struct {\n\tValues []Expression // nil/empty for ELSE\n\tIsElse bool\n\tBody   []Statement\n}\n```\n\n---\n\n## Summary\n\nAll four components are now available:\n\n1. **`parseProtocolDecl`** - Handles protocol declarations with IS form (simple/sequential) or CASE form (variant). Does NOT currently validate trailing colons.\n\n2. **`parseCaseStatement`** - Parses CASE statements with selector and choices. Currently only parses single values per choice (does NOT support comma-separated values as per issue #75).\n\n3. **`parseAltCase`** - Parses individual ALT cases with scoped declarations, simple guards, and indexed channels. Does NOT currently support parenthesized guards as per issue #78.\n\n4. **`CaseChoice`** - Struct to represent a single case choice with `Values` (Expression slice), `IsElse` flag, and `Body` (Statement slice)."
  },
  {
    "type": "text",
    "text": "agentId: a5b0584e2b31ceeaf (for resuming to continue this agent's work if needed)\n<usage>total_tokens: 33916\ntool_uses: 6\nduration_ms: 28401</usage>"
  }
]

Task #1 created successfully: Fix #73: Protocol declaration trailing colon terminator

Task #2 created successfully: Fix #75: CASE with comma-separated values and ELSE

Task #3 created successfully: Fix #78: Parenthesized guard expressions in ALT

Task #4 created successfully: Fix #79: Multi-line abbreviations (IS continuation)

Task #5 created successfully: Add tests and verify all fixes

   844→func (p *Parser) parseProtocolDecl() *ast.ProtocolDecl {
   845→	decl := &ast.ProtocolDecl{Token: p.curToken}
   846→
   847→	// Expect protocol name
   848→	if !p.expectPeek(lexer.IDENT) {
   849→		return nil
   850→	}
   851→	decl.Name = p.curToken.Literal
   852→
   853→	// Check if this is IS form (simple/sequential) or CASE form (variant)
   854→	if p.peekTokenIs(lexer.NEWLINE) || p.peekTokenIs(lexer.INDENT) {
   855→		// Could be variant: PROTOCOL NAME \n INDENT CASE ...
   856→		// Skip newlines
   857→		for p.peekTokenIs(lexer.NEWLINE) {
   858→			p.nextToken()
   859→		}
   860→
   861→		if p.peekTokenIs(lexer.INDENT) {
   862→			p.nextToken() // consume INDENT
   863→			p.nextToken() // move into block
   864→
   865→			if p.curTokenIs(lexer.CASE) {
   866→				// Variant protocol
   867→				decl.Kind = "variant"
   868→				decl.Variants = p.parseProtocolVariants()
   869→				p.protocolNames[decl.Name] = true
   870→				p.protocolDefs[decl.Name] = decl
   871→				return decl
   872→			}
   873→		}
   874→
   875→		p.addError("expected IS or CASE in protocol declaration")
   876→		return nil
   877→	}
   878→
   879→	// IS form: PROTOCOL NAME IS TYPE [; TYPE]*
   880→	if !p.expectPeek(lexer.IS) {
   881→		return nil
   882→	}
   883→
   884→	// Parse type list
   885→	p.nextToken()
   886→	typeName := p.parseProtocolTypeName()
   887→	if typeName == "" {
   888→		return nil
   889→	}
   890→	decl.Types = append(decl.Types, typeName)
   891→
   892→	// Check for sequential: ; TYPE
   893→	for p.peekTokenIs(lexer.SEMICOLON) {
   894→		p.nextToken() // move to ;
   895→		p.nextToken() // move past ;
   896→		typeName = p.parseProtocolTypeName()
   897→		if typeName == "" {
   898→			return nil
   899→		}
   900→		decl.Types = append(decl.Types, typeName)
   901→	}
   902→
   903→	if len(decl.Types) == 1 {
   904→		decl.Kind = "simple"
   905→	} else {
   906→		decl.Kind = "sequential"
   907→	}
   908→
   909→	p.protocolNames[decl.Name] = true
   910→	p.protocolDefs[decl.Name] = decl
   911→	return decl
   912→}
   913→
   914→func (p *Parser) parseProtocolTypeName() string {
   915→	switch p.curToken.Type {
   916→	case lexer.INT_TYPE:
   917→		return "INT"
   918→	case lexer.BYTE_TYPE:

  2579→func (p *Parser) parseCaseStatement() *ast.CaseStatement {
  2580→	stmt := &ast.CaseStatement{Token: p.curToken}
  2581→
  2582→	// Parse selector expression on the same line
  2583→	p.nextToken()
  2584→	stmt.Selector = p.parseExpression(LOWEST)
  2585→
  2586→	// Skip to next line
  2587→	for p.peekTokenIs(lexer.NEWLINE) {
  2588→		p.nextToken()
  2589→	}
  2590→
  2591→	// Expect INDENT
  2592→	if !p.peekTokenIs(lexer.INDENT) {
  2593→		p.addError("expected indented block after CASE")
  2594→		return stmt
  2595→	}
  2596→	p.nextToken() // consume INDENT
  2597→	startLevel := p.indentLevel
  2598→	p.nextToken() // move into block
  2599→
  2600→	// Parse case choices
  2601→	for !p.curTokenIs(lexer.EOF) {
  2602→		// Skip newlines
  2603→		for p.curTokenIs(lexer.NEWLINE) {
  2604→			p.nextToken()
  2605→		}
  2606→
  2607→		// Handle DEDENT tokens
  2608→		for p.curTokenIs(lexer.DEDENT) {
  2609→			if p.indentLevel < startLevel {
  2610→				return stmt
  2611→			}
  2612→			p.nextToken()
  2613→		}
  2614→
  2615→		// Skip any more newlines after DEDENT
  2616→		for p.curTokenIs(lexer.NEWLINE) {
  2617→			p.nextToken()
  2618→		}
  2619→
  2620→		if p.curTokenIs(lexer.EOF) {
  2621→			break
  2622→		}
  2623→
  2624→		if p.indentLevel < startLevel {
  2625→			break
  2626→		}
  2627→
  2628→		// Safety guard: record position before parsing to detect no-progress
  2629→		prevToken := p.curToken
  2630→		prevPeek := p.peekToken
  2631→
  2632→		choice := ast.CaseChoice{}
  2633→
  2634→		if p.curTokenIs(lexer.ELSE) {
  2635→			choice.IsElse = true
  2636→		} else {
  2637→			// Parse value expression
  2638→			choice.Values = append(choice.Values, p.parseExpression(LOWEST))
  2639→		}
  2640→
  2641→		// Skip newlines and expect INDENT for body
  2642→		for p.peekTokenIs(lexer.NEWLINE) {
  2643→			p.nextToken()
  2644→		}
  2645→
  2646→		if p.peekTokenIs(lexer.INDENT) {
  2647→			p.nextToken() // consume INDENT
  2648→			p.nextToken() // move to body
  2649→			choice.Body = p.parseBodyStatements()
  2650→		}
  2651→
  2652→		stmt.Choices = append(stmt.Choices, choice)
  2653→
  2654→		// No-progress guard: if we haven't moved, break to prevent infinite loop
  2655→		if p.curToken == prevToken && p.peekToken == prevPeek {
  2656→			break
  2657→		}
  2658→	}
  2659→
  2660→	return stmt
  2661→}
  2662→
  2663→// Expression parsing using Pratt parsing
  2664→
  2665→func (p *Parser) parseExpression(precedence int) ast.Expression {
  2666→	var left ast.Expression
  2667→
  2668→	switch p.curToken.Type {

  1665→func (p *Parser) parseAltCase() *ast.AltCase {
  1666→	altCase := &ast.AltCase{}
  1667→
  1668→	// Parse scoped declarations before the channel input (e.g., BYTE ch:, VAL INT X IS expr:)
  1669→	for p.isAltDeclStart() {
  1670→		stmt := p.parseStatement()
  1671→		if stmt != nil {
  1672→			altCase.Declarations = append(altCase.Declarations, stmt)
  1673→		}
  1674→		// Advance past the end of the declaration
  1675→		if !p.curTokenIs(lexer.NEWLINE) && !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
  1676→			p.nextToken()
  1677→		}
  1678→		// Skip newlines to reach next token
  1679→		for p.curTokenIs(lexer.NEWLINE) {
  1680→			p.nextToken()
  1681→		}
  1682→	}
  1683→
  1684→	// Check for guard: expression & channel ? var
  1685→	// For now, we expect: channel ? var (no guard support yet)
  1686→	// or: guard & channel ? var
  1687→
  1688→	// First token should be identifier (channel name or guard start)
  1689→	if !p.curTokenIs(lexer.IDENT) && !p.curTokenIs(lexer.TRUE) && !p.curTokenIs(lexer.FALSE) {
  1690→		p.addError(fmt.Sprintf("expected channel name or guard in ALT case, got %s", p.curToken.Type))
  1691→		return nil
  1692→	}
  1693→
  1694→	// Look ahead to determine if this is a guard or channel
  1695→	// If next token is & then we have a guard
  1696→	// If next token is ? then it's a channel/timer receive
  1697→	if p.peekTokenIs(lexer.RECEIVE) {
  1698→		name := p.curToken.Literal
  1699→		if p.timerNames[name] {
  1700→			// Timer case: tim ? AFTER deadline
  1701→			altCase.IsTimer = true
  1702→			altCase.Timer = name
  1703→			p.nextToken() // move to ?
  1704→			if !p.expectPeek(lexer.AFTER) {
  1705→				return nil
  1706→			}
  1707→			p.nextToken() // move past AFTER
  1708→			altCase.Deadline = p.parseExpression(LOWEST)
  1709→		} else {
  1710→			// Simple case: channel ? var
  1711→			altCase.Channel = name
  1712→			p.nextToken() // move to ?
  1713→			if !p.expectPeek(lexer.IDENT) {
  1714→				return nil
  1715→			}
  1716→			altCase.Variable = p.curToken.Literal
  1717→		}
  1718→	} else if p.peekTokenIs(lexer.LBRACKET) {
  1719→		// Indexed channel case: cs[i] ? var
  1720→		name := p.curToken.Literal
  1721→		altCase.Channel = name
  1722→		p.nextToken() // move to [
  1723→		p.nextToken() // move past [
  1724→		altCase.ChannelIndex = p.parseExpression(LOWEST)
  1725→		if !p.expectPeek(lexer.RBRACKET) {
  1726→			return nil
  1727→		}
  1728→		if !p.expectPeek(lexer.RECEIVE) {
  1729→			return nil
  1730→		}
  1731→		if !p.expectPeek(lexer.IDENT) {
  1732→			return nil
  1733→		}
  1734→		altCase.Variable = p.curToken.Literal
  1735→	} else {
  1736→		// Could be a guard followed by & channel ? var
  1737→		// For simplicity, parse expression until we hit &
  1738→		// For now, only support simple TRUE/FALSE or identifier guards
  1739→		guard := p.parseExpression(LOWEST)
  1740→		altCase.Guard = guard
  1741→
  1742→		// Expect &
  1743→		if !p.peekTokenIs(lexer.AMPERSAND) {
  1744→			p.addError("expected & after guard in ALT case")
  1745→			return nil
  1746→		}
  1747→		p.nextToken() // move to &
  1748→		p.nextToken() // move past &
  1749→
  1750→		// Now expect channel ? var or channel[index] ? var
  1751→		if !p.curTokenIs(lexer.IDENT) {
  1752→			p.addError(fmt.Sprintf("expected channel name after guard, got %s", p.curToken.Type))
  1753→			return nil
  1754→		}
  1755→		altCase.Channel = p.curToken.Literal
  1756→
  1757→		if p.peekTokenIs(lexer.LBRACKET) {
  1758→			// Indexed channel with guard: guard & cs[i] ? var
  1759→			p.nextToken() // move to [
  1760→			p.nextToken() // move past [
  1761→			altCase.ChannelIndex = p.parseExpression(LOWEST)
  1762→			if !p.expectPeek(lexer.RBRACKET) {
  1763→				return nil
  1764→			}
  1765→		}
  1766→
  1767→		if !p.expectPeek(lexer.RECEIVE) {
  1768→			return nil
  1769→		}
  1770→		if !p.expectPeek(lexer.IDENT) {
  1771→			return nil
  1772→		}
  1773→		altCase.Variable = p.curToken.Literal
  1774→	}
  1775→
  1776→	// Skip to next line for the body
  1777→	for p.peekTokenIs(lexer.NEWLINE) {
  1778→		p.nextToken()
  1779→	}
  1780→
  1781→	// Expect INDENT for body
  1782→	if !p.peekTokenIs(lexer.INDENT) {
  1783→		p.addError("expected indented body after ALT case")
  1784→		return altCase
  1785→	}
  1786→	p.nextToken() // consume INDENT
  1787→	p.nextToken() // move into body
  1788→
  1789→	altCase.Body = p.parseBodyStatements()
  1790→
  1791→	return altCase
  1792→}
  1793→
  1794→func (p *Parser) parseBlockStatements() []ast.Statement {

   415→// isContinuationOp returns true if the given token type, when appearing at the
   416→// end of a line, indicates that the expression continues on the next line.
   417→// This causes NEWLINE and INDENT/DEDENT suppression on the continuation line.
   418→func isContinuationOp(t TokenType) bool {
   419→	switch t {
   420→	case AND, OR,
   421→		PLUS, MINUS, MULTIPLY, DIVIDE, MODULO,
   422→		PLUS_KW, MINUS_KW, TIMES,
   423→		EQ, NEQ, LT, GT, LE, GE,
   424→		BITAND, BITOR, BITXOR, LSHIFT, RSHIFT,
   425→		ASSIGN, AFTER:
   426→		return true
   427→	}
   428→	return false
   429→}
   430→
   431→// Tokenize returns all tokens from the input
   432→func Tokenize(input string) []Token {
   433→	// Ensure input ends with newline for consistent processing
   434→	if !strings.HasSuffix(input, "\n") {

ast/ast.go:397:type AltCase struct {
/home/david/projects/code-associates/occam2go/ast/ast.go-398-	Guard        Expression  // optional guard condition (nil if no guard)
/home/david/projects/code-associates/occam2go/ast/ast.go-399-	Channel      string      // channel name
/home/david/projects/code-associates/occam2go/ast/ast.go-400-	ChannelIndex Expression  // non-nil for cs[i] ? x in ALT
/home/david/projects/code-associates/occam2go/ast/ast.go-401-	Variable     string      // variable to receive into
/home/david/projects/code-associates/occam2go/ast/ast.go-402-	Body         []Statement // the body to execute
/home/david/projects/code-associates/occam2go/ast/ast.go-403-	IsTimer      bool        // true if this is a timer AFTER case
/home/david/projects/code-associates/occam2go/ast/ast.go-404-	Timer        string      // timer name (when IsTimer)
/home/david/projects/code-associates/occam2go/ast/ast.go-405-	Deadline     Expression  // AFTER deadline expression (when IsTimer)
ast/ast.go-406-	Declarations []Statement / scoped declarations before channel input (e.g., BYTE ch:)
/home/david/projects/code-associates/occam2go/ast/ast.go-407-}
/home/david/projects/code-associates/occam2go/ast/ast.go-408-
ast/ast.go-409-/ TimerDecl represents a timer declaration: TIMER tim:
/home/david/projects/code-associates/occam2go/ast/ast.go-410-type TimerDecl struct {
/home/david/projects/code-associates/occam2go/ast/ast.go-411-	Token lexer.Token // the TIMER token
/home/david/projects/code-associates/occam2go/ast/ast.go-412-	Names []string    // timer variable names

75:	SKIP
170:	SKIP:      "SKIP",
223:	"SKIP":  SKIP,

190:	case lexer.SKIP:

   188→	case lexer.ALT:
   189→		return p.parseAltBlock()
   190→	case lexer.SKIP:
   191→		return &ast.Skip{Token: p.curToken}
   192→	case lexer.STOP:
   193→		return &ast.Stop{Token: p.curToken}
   194→	case lexer.PROC:
   195→		return p.parseProcDecl()
   196→	case lexer.WHILE:
   197→		return p.parseWhileLoop()

520:	case *ast.AltBlock:
593:	case *ast.AltBlock:
654:	case *ast.AltBlock:
742:	case *ast.AltBlock:
896:	case *ast.AltBlock:
1034:	case *ast.AltBlock:
1035:		g.generateAltBlock(s)
1388:	case *ast.AltBlock:
1493:	case *ast.AltBlock:
1746:func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
1807:func (g *Generator) generateReplicatedAlt(alt *ast.AltBlock) {
2800:	case *ast.AltBlock:
2956:	case *ast.AltBlock:

  1746→func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
  1747→	if alt.Replicator != nil {
  1748→		g.generateReplicatedAlt(alt)
  1749→		return
  1750→	}
  1751→
  1752→	// ALT becomes Go select statement
  1753→	// For guards, we use a pattern with nil channels
  1754→
  1755→	// Check if any cases have guards
  1756→	hasGuards := false
  1757→	for _, c := range alt.Cases {
  1758→		if c.Guard != nil {
  1759→			hasGuards = true
  1760→			break
  1761→		}
  1762→	}
  1763→
  1764→	if hasGuards {
  1765→		// Generate channel variables for guarded cases
  1766→		for i, c := range alt.Cases {
  1767→			if c.Guard != nil {
  1768→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1769→				g.write(fmt.Sprintf("var _alt%d chan ", i))
  1770→				// We don't know the channel type here, so use interface{}
  1771→				// Actually, we should use the same type as the original channel
  1772→				// For now, let's just reference the original channel conditionally
  1773→				g.write(fmt.Sprintf("int = nil\n")) // Assuming int for now
  1774→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1775→				g.write(fmt.Sprintf("if "))
  1776→				g.generateExpression(c.Guard)
  1777→				g.write(fmt.Sprintf(" { _alt%d = %s }\n", i, goIdent(c.Channel)))
  1778→			}
  1779→		}
  1780→	}
  1781→
  1782→	g.writeLine("select {")
  1783→	for i, c := range alt.Cases {
  1784→		g.builder.WriteString(strings.Repeat("\t", g.indent))
  1785→		if c.IsTimer {
  1786→			g.write("case <-time.After(time.Duration(")
  1787→			g.generateExpression(c.Deadline)
  1788→			g.write(" - int(time.Now().UnixMicro())) * time.Microsecond):\n")
  1789→		} else if c.Guard != nil {
  1790→			g.write(fmt.Sprintf("case %s = <-_alt%d:\n", goIdent(c.Variable), i))
  1791→		} else if c.ChannelIndex != nil {
  1792→			g.write(fmt.Sprintf("case %s = <-%s[", goIdent(c.Variable), goIdent(c.Channel)))
  1793→			g.generateExpression(c.ChannelIndex)
  1794→			g.write("]:\n")
  1795→		} else {
  1796→			g.write(fmt.Sprintf("case %s = <-%s:\n", goIdent(c.Variable), goIdent(c.Channel)))
  1797→		}
  1798→		g.indent++
  1799→		for _, s := range c.Body {
  1800→			g.generateStatement(s)
  1801→		}
  1802→		g.indent--
  1803→	}
  1804→	g.writeLine("}")
  1805→}
  1806→
  1807→func (g *Generator) generateReplicatedAlt(alt *ast.AltBlock) {
  1808→	// Replicated ALT: ALT i = start FOR count
  1809→	// Uses reflect.Select for runtime-variable case count
  1810→	if len(alt.Cases) == 0 {

67:	IS
162:	IS:        "IS",

162:	IS:        "IS",
215:	"IS":       IS,

936:func (p *Parser) parseProtocolVariants() []ast.ProtocolVariant {
937-	var variants []ast.ProtocolVariant
938-
939-	// Skip to next line after CASE
940-	for p.peekTokenIs(lexer.NEWLINE) {
941-		p.nextToken()
942-	}
943-
944-	// Expect INDENT
945-	if !p.peekTokenIs(lexer.INDENT) {
946-		p.addError("expected indented block after CASE in protocol")
947-		return variants
948-	}
949-	p.nextToken() // consume INDENT
950-	startLevel := p.indentLevel
951-	p.nextToken() // move into block
952-
953-	for !p.curTokenIs(lexer.EOF) {
954-		// Skip newlines
955-		for p.curTokenIs(lexer.NEWLINE) {
956-			p.nextToken()
957-		}
958-
959-		// Handle DEDENT tokens
960-		for p.curTokenIs(lexer.DEDENT) {
961-			if p.indentLevel < startLevel {
962-				return variants
963-			}
964-			p.nextToken()
965-		}
966-
967-		// Skip any more newlines after DEDENT
968-		for p.curTokenIs(lexer.NEWLINE) {
969-			p.nextToken()
970-		}
971-
972-		if p.curTokenIs(lexer.EOF) {
973-			break
974-		}
975-
976-		if p.indentLevel < startLevel {
977-			break
978-		}
979-
980-		/ Parse variant: tag [; TYPE]*
981-		if !p.curTokenIs(lexer.IDENT) {
982-			p.addError(fmt.Sprintf("expected variant tag name, got %s", p.curToken.Type))
983-			return variants
984-		}
985-
986-		v := ast.ProtocolVariant{
987-			Tag: p.curToken.Literal,
988-		}
989-
990-		// Parse optional types after semicolons
991-		for p.peekTokenIs(lexer.SEMICOLON) {
992-			p.nextToken() // move to ;
993-			p.nextToken() // move past ;
994-			typeName := p.parseProtocolTypeName()
995-			if typeName == "" {
996-				return variants

176-	case lexer.CHAN:
177-		return p.parseChanDecl()
178:	case lexer.PROTOCOL:
179:		return p.parseProtocolDecl()
180-	case lexer.RECORD:
181-		return p.parseRecordDecl()
--
842-}
843-
844:func (p *Parser) parseProtocolDecl() *ast.ProtocolDecl {
845-	decl := &ast.ProtocolDecl{Token: p.curToken}
846-
--
853-	// Check if this is IS form (simple/sequential) or CASE form (variant)
854-	if p.peekTokenIs(lexer.NEWLINE) || p.peekTokenIs(lexer.INDENT) {
855:		// Could be variant: PROTOCOL NAME \n INDENT CASE ...
856-		// Skip newlines
857-		for p.peekTokenIs(lexer.NEWLINE) {
--
877-	}
878-
879:	// IS form: PROTOCOL NAME IS TYPE [; TYPE]*
880-	if !p.expectPeek(lexer.IS) {
881-		return nil

253-	}
254-
255:	if !p.expectPeek(lexer.COLON) {
256-		return nil
257-	}
--
278-		value := p.parseExpression(LOWEST)
279-
280:		if !p.expectPeek(lexer.COLON) {
281-			return nil
282-		}
--
307-	}
308-
309:	if !p.expectPeek(lexer.COLON) {
310-		return nil
311-	}
--
355-		p.nextToken() // move to expression
356-		value := p.parseExpression(LOWEST)
357:		if !p.expectPeek(lexer.COLON) {
358-			return nil
359-		}
--
387-		}
388-		source := p.curToken.Literal
389:		if !p.expectPeek(lexer.COLON) {
390-			return nil
391-		}
--
411-
412-	// Expect colon
413:	if !p.expectPeek(lexer.COLON) {
414-		return nil
415-	}
--
456-
457-	// Expect colon
458:	if !p.expectPeek(lexer.COLON) {
459-		return nil
460-	}
--
587-		}
588-
589:		if !p.expectPeek(lexer.COLON) {
590-			return nil
591-		}
--
621-	}
622-
623:	if !p.expectPeek(lexer.COLON) {
624-		return nil
625-	}
--
718-
719-		/ Check if this is a variant send: first token is an identifier that is a variant tag
720:		if p.curTokenIs(lexer.IDENT) && p.peekTokenIs(lexer.SEMICOLON) {
721-			possibleTag := p.curToken.Literal
722-			if p.isVariantTag(possibleTag) {
723-				stmt.VariantTag = possibleTag
724-				p.nextToken() // move to ;
725:				for p.curTokenIs(lexer.SEMICOLON) {
726-					p.nextToken() // move past ;
727-					val := p.parseExpression(LOWEST)
--
735-
736-		// Check for sequential send
737:		for p.peekTokenIs(lexer.SEMICOLON) {
738-			p.nextToken() // move to ;
739-			p.nextToken() // move past ;
--
768-
769-		// Check for sequential receive
770:		for p.peekTokenIs(lexer.SEMICOLON) {
771-			p.nextToken() // move to ;
772-			if !p.expectPeek(lexer.IDENT) {
--
835-	}
836-
837:	if !p.expectPeek(lexer.COLON) {
838-		return nil
839-	}
--
891-
892-	/ Check for sequential: ; TYPE
893:	for p.peekTokenIs(lexer.SEMICOLON) {
894-		p.nextToken() // move to ;
895-		p.nextToken() // move past ;
--
989-
990-		// Parse optional types after semicolons
991:		for p.peekTokenIs(lexer.SEMICOLON) {
992-			p.nextToken() // move to ;
993-			p.nextToken() // move past ;
--
1090-
1091-		// Expect colon
1092:		if !p.expectPeek(lexer.COLON) {
1093-			return nil
1094-		}
--
1125-	}
1126-
1127:	if !p.expectPeek(lexer.COLON) {
1128-		return nil
1129-	}
--
1150-	}
1151-
1152:	if !p.expectPeek(lexer.COLON) {
1153-		return nil
1154-	}
--
1184-
1185-	/ Check if this is a variant send: first token is an identifier that is a variant tag
1186:	// We detect this by checking if the identifier is followed by SEMICOLON
1187-	// and the identifier is NOT followed by an operator (i.e., it's a bare tag name)
1188:	if p.curTokenIs(lexer.IDENT) && p.peekTokenIs(lexer.SEMICOLON) {
1189-		// Could be variant send (tag ; values) or expression ; values
1190-		// Check if the identifier is a known protocol variant tag
1191:		// For simplicity, if IDENT is followed by SEMICOLON and the ident is
1192-		// not followed by an operator, treat it as a variant tag
1193-		// We save the ident and check further
--
1198-			p.nextToken() // move to ;
1199-			// Parse remaining values after the tag
1200:			for p.curTokenIs(lexer.SEMICOLON) {
1201-				p.nextToken() // move past ;
1202-				val := p.parseExpression(LOWEST)
--
1210-
1211-	/ Check for sequential send: c ! expr ; expr ; ...
1212:	for p.peekTokenIs(lexer.SEMICOLON) {
1213-		p.nextToken() // move to ;
1214-		p.nextToken() // move past ;
--
1256-
1257-	/ Check for sequential receive: c ? x ; y ; z
1258:	for p.peekTokenIs(lexer.SEMICOLON) {
1259-		p.nextToken() // move to ;
1260-		if !p.expectPeek(lexer.IDENT) {
--
1330-
1331-		/ Parse optional variables after semicolons: tag ; x ; y
1332:		for p.peekTokenIs(lexer.SEMICOLON) {
1333-			p.nextToken() // move to ;
1334-			if !p.expectPeek(lexer.IDENT) {
--
1426-		vc.Tag = p.curToken.Literal
1427-
1428:		for p.peekTokenIs(lexer.SEMICOLON) {
1429-			p.nextToken() // move to ;
1430-			if !p.expectPeek(lexer.IDENT) {
--
1970-procBodyDone:
1971-
1972:	// Optionally consume KRoC-style colon terminator
1973:	if p.peekTokenIs(lexer.COLON) {
1974-		p.nextToken()
1975-	}
--
2268-		}
2269-
2270:		// Optionally consume KRoC-style colon terminator
2271:		if p.peekTokenIs(lexer.COLON) {
2272-			p.nextToken()
2273-		}
--
2354-	}
2355-
2356:	// Optionally consume KRoC-style colon terminator
2357:	if p.peekTokenIs(lexer.COLON) {
2358-		p.nextToken()
2359-	}

Updated task #1 status

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

Updated task #1 status

Updated task #2 status

47:	COMMA     // ,
144:	COMMA:     ",",

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

346:		case *ast.CaseStatement:
383:		case *ast.CaseStatement:
559:	case *ast.CaseStatement:
632:	case *ast.CaseStatement:
708:	case *ast.CaseStatement:
781:	case *ast.CaseStatement:
865:	case *ast.CaseStatement:
1051:	case *ast.CaseStatement:
1052:		g.generateCaseStatement(s)
1382:	case *ast.CaseStatement:
1434:	case *ast.CaseStatement:
1487:	case *ast.CaseStatement:
2457:func (g *Generator) generateCaseStatement(stmt *ast.CaseStatement) {
2786:	case *ast.CaseStatement:
2852:	case *ast.CaseStatement:
2925:	case *ast.CaseStatement:

  2457→func (g *Generator) generateCaseStatement(stmt *ast.CaseStatement) {
  2458→	g.builder.WriteString(strings.Repeat("\t", g.indent))
  2459→	g.write("switch ")
  2460→	g.generateExpression(stmt.Selector)
  2461→	g.write(" {\n")
  2462→
  2463→	for _, choice := range stmt.Choices {
  2464→		if choice.IsElse {
  2465→			g.writeLine("default:")
  2466→		} else {
  2467→			g.builder.WriteString(strings.Repeat("\t", g.indent))
  2468→			g.write("case ")
  2469→			for i, val := range choice.Values {
  2470→				if i > 0 {
  2471→					g.write(", ")
  2472→				}
  2473→				g.generateExpression(val)
  2474→			}
  2475→			g.write(":\n")
  2476→		}
  2477→		g.indent++
  2478→		for _, s := range choice.Body {
  2479→			g.generateStatement(s)
  2480→		}
  2481→		g.indent--
  2482→	}
  2483→
  2484→	g.writeLine("}")
  2485→}
  2486→
  2487→func (g *Generator) generateExpression(expr ast.Expression) {
  2488→	switch e := expr.(type) {
  2489→	case *ast.Identifier:
  2490→		if g.refParams[e.Value] {
  2491→			g.write("*" + goIdent(e.Value))
  2492→		} else {
  2493→			g.write(goIdent(e.Value))
  2494→		}
  2495→	case *ast.IntegerLiteral:
  2496→		g.write(fmt.Sprintf("%d", e.Value))
  2497→	case *ast.StringLiteral:
  2498→		g.write(fmt.Sprintf("%q", e.Value))
  2499→	case *ast.ByteLiteral:
  2500→		g.write(fmt.Sprintf("byte(%d)", e.Value))
  2501→	case *ast.BooleanLiteral:
  2502→		if e.Value {
  2503→			g.write("true")
  2504→		} else {
  2505→			g.write("false")
  2506→		}

Updated task #2 status

Updated task #3 status

No matches found

   397→type AltCase struct {
   398→	Guard        Expression  // optional guard condition (nil if no guard)
   399→	Channel      string      // channel name
   400→	ChannelIndex Expression  // non-nil for cs[i] ? x in ALT
   401→	Variable     string      // variable to receive into
   402→	Body         []Statement // the body to execute
   403→	IsTimer      bool        // true if this is a timer AFTER case
   404→	Timer        string      // timer name (when IsTimer)
   405→	Deadline     Expression  // AFTER deadline expression (when IsTimer)
   406→	Declarations []Statement // scoped declarations before channel input (e.g., BYTE ch:)
   407→}
   408→
   409→// TimerDecl represents a timer declaration: TIMER tim:
   410→type TimerDecl struct {
   411→	Token lexer.Token // the TIMER token

The file /home/david/projects/code-associates/occam2go/ast/ast.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

  1718→			altCase.Deadline = p.parseExpression(LOWEST)
  1719→		} else {
  1720→			// Simple case: channel ? var
  1721→			altCase.Channel = name
  1722→			p.nextToken() // move to ?
  1723→			if !p.expectPeek(lexer.IDENT) {
  1724→				return nil
  1725→			}
  1726→			altCase.Variable = p.curToken.Literal
  1727→		}
  1728→	} else if p.peekTokenIs(lexer.LBRACKET) {
  1729→		// Indexed channel case: cs[i] ? var
  1730→		name := p.curToken.Literal
  1731→		altCase.Channel = name
  1732→		p.nextToken() // move to [
  1733→		p.nextToken() // move past [
  1734→		altCase.ChannelIndex = p.parseExpression(LOWEST)
  1735→		if !p.expectPeek(lexer.RBRACKET) {
  1736→			return nil
  1737→		}
  1738→		if !p.expectPeek(lexer.RECEIVE) {
  1739→			return nil
  1740→		}
  1741→		if !p.expectPeek(lexer.IDENT) {
  1742→			return nil
  1743→		}
  1744→		altCase.Variable = p.curToken.Literal
  1745→	} else {
  1746→		// Could be a guard followed by & channel ? var
  1747→		// For simplicity, parse expression until we hit &
  1748→		// For now, only support simple TRUE/FALSE or identifier guards
  1749→		guard := p.parseExpression(LOWEST)
  1750→		altCase.Guard = guard
  1751→
  1752→		// Expect &
  1753→		if !p.peekTokenIs(lexer.AMPERSAND) {
  1754→			p.addError("expected & after guard in ALT case")
  1755→			return nil
  1756→		}
  1757→		p.nextToken() // move to &
  1758→		p.nextToken() // move past &
  1759→
  1760→		// Now expect channel ? var or channel[index] ? var
  1761→		if !p.curTokenIs(lexer.IDENT) {
  1762→			p.addError(fmt.Sprintf("expected channel name after guard, got %s", p.curToken.Type))
  1763→			return nil
  1764→		}
  1765→		altCase.Channel = p.curToken.Literal
  1766→
  1767→		if p.peekTokenIs(lexer.LBRACKET) {
  1768→			// Indexed channel with guard: guard & cs[i] ? var
  1769→			p.nextToken() // move to [
  1770→			p.nextToken() // move past [
  1771→			altCase.ChannelIndex = p.parseExpression(LOWEST)
  1772→			if !p.expectPeek(lexer.RBRACKET) {
  1773→				return nil
  1774→			}
  1775→		}
  1776→
  1777→		if !p.expectPeek(lexer.RECEIVE) {
  1778→			return nil
  1779→		}

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

Updated task #3 status

Updated task #4 status

The file /home/david/projects/code-associates/occam2go/lexer/lexer.go has been updated successfully.

Updated task #4 status

Updated task #5 status

?   	github.com/codeassociates/occam2go	[no test files]
?   	github.com/codeassociates/occam2go/ast	[no test files]
ok  	github.com/codeassociates/occam2go/codegen	17.520s
ok  	github.com/codeassociates/occam2go/lexer	0.002s
ok  	github.com/codeassociates/occam2go/modgen	(cached)
ok  	github.com/codeassociates/occam2go/parser	0.002s
ok  	github.com/codeassociates/occam2go/preproc	(cached)

/home/david/projects/code-associates/occam2go/codegen/e2e_preproc_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_helpers_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_record_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_proc_func_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_replicator_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_basic_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_control_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_phase2_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_course_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_intrinsics_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_strings_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_misc_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_params_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_retypes_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_concurrency_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_types_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_array_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_protocol_test.go
/home/david/projects/code-associates/occam2go/codegen/codegen_test.go

     1→package codegen
     2→
     3→import (
     4→	"os"
     5→	"os/exec"
     6→	"path/filepath"
     7→	"testing"
     8→
     9→	"github.com/codeassociates/occam2go/lexer"
    10→	"github.com/codeassociates/occam2go/parser"
    11→	"github.com/codeassociates/occam2go/preproc"
    12→)
    13→
    14→// transpileCompileRun takes Occam source, transpiles to Go, compiles, runs,
    15→// and returns the stdout output
    16→func transpileCompileRun(t *testing.T, occamSource string) string {
    17→	t.Helper()
    18→
    19→	// Transpile
    20→	l := lexer.New(occamSource)
    21→	p := parser.New(l)
    22→	program := p.ParseProgram()
    23→
    24→	if len(p.Errors()) > 0 {
    25→		for _, err := range p.Errors() {
    26→			t.Errorf("parser error: %s", err)
    27→		}
    28→		t.FailNow()
    29→	}
    30→
    31→	gen := New()
    32→	goCode := gen.Generate(program)
    33→
    34→	// Create temp directory for this test
    35→	tmpDir, err := os.MkdirTemp("", "occam2go-test-*")
    36→	if err != nil {
    37→		t.Fatalf("failed to create temp dir: %v", err)
    38→	}
    39→	defer os.RemoveAll(tmpDir)
    40→
    41→	// Write Go source
    42→	goFile := filepath.Join(tmpDir, "main.go")
    43→	if err := os.WriteFile(goFile, []byte(goCode), 0644); err != nil {
    44→		t.Fatalf("failed to write Go file: %v", err)
    45→	}
    46→
    47→	// Compile
    48→	binFile := filepath.Join(tmpDir, "main")
    49→	compileCmd := exec.Command("go", "build", "-o", binFile, goFile)
    50→	compileOutput, err := compileCmd.CombinedOutput()
    51→	if err != nil {
    52→		t.Fatalf("compilation failed: %v\nOutput: %s\nGo code:\n%s", err, compileOutput, goCode)
    53→	}
    54→
    55→	// Run
    56→	runCmd := exec.Command(binFile)
    57→	output, err := runCmd.CombinedOutput()
    58→	if err != nil {
    59→		t.Fatalf("execution failed: %v\nOutput: %s", err, output)
    60→	}
    61→
    62→	return string(output)
    63→}
    64→
    65→// transpileCompileRunFromFile takes an occam file path, preprocesses it,
    66→// then transpiles, compiles, and runs.
    67→func transpileCompileRunFromFile(t *testing.T, mainFile string, includePaths []string) string {
    68→	t.Helper()
    69→
    70→	pp := preproc.New(preproc.WithIncludePaths(includePaths))
    71→	expanded, err := pp.ProcessFile(mainFile)
    72→	if err != nil {
    73→		t.Fatalf("preprocessor error: %v", err)
    74→	}
    75→	if len(pp.Errors()) > 0 {
    76→		for _, e := range pp.Errors() {
    77→			t.Errorf("preprocessor warning: %s", e)
    78→		}
    79→	}
    80→
    81→	return transpileCompileRun(t, expanded)
    82→}
    83→

     1→package codegen
     2→
     3→import "testing"
     4→
     5→func TestE2E_SimpleProtocol(t *testing.T) {
     6→	// Simple protocol: just a named type alias
     7→	occam := `PROTOCOL SIGNAL IS INT
     8→
     9→SEQ
    10→  CHAN OF SIGNAL c:
    11→  INT result:
    12→  PAR
    13→    c ! 42
    14→    c ? result
    15→  print.int(result)
    16→`
    17→	output := transpileCompileRun(t, occam)
    18→	expected := "42\n"
    19→	if output != expected {
    20→		t.Errorf("expected %q, got %q", expected, output)
    21→	}
    22→}
    23→
    24→func TestE2E_SequentialProtocol(t *testing.T) {
    25→	// Sequential protocol: send/receive multiple values
    26→	occam := `PROTOCOL PAIR IS INT ; INT
    27→
    28→SEQ
    29→  CHAN OF PAIR c:
    30→  INT x, y:
    31→  PAR
    32→    c ! 10 ; 20
    33→    c ? x ; y
    34→  print.int(x)
    35→  print.int(y)
    36→`
    37→	output := transpileCompileRun(t, occam)
    38→	expected := "10\n20\n"
    39→	if output != expected {
    40→		t.Errorf("expected %q, got %q", expected, output)
    41→	}
    42→}
    43→
    44→func TestE2E_VariantProtocol(t *testing.T) {
    45→	// Variant protocol: tagged union with CASE receive
    46→	occam := `PROTOCOL MSG
    47→  CASE
    48→    data; INT
    49→    quit
    50→
    51→SEQ
    52→  CHAN OF MSG c:
    53→  INT result:
    54→  result := 0
    55→  PAR
    56→    c ! data ; 42
    57→    c ? CASE
    58→      data ; result
    59→        print.int(result)
    60→      quit
    61→        print.int(0)
    62→`
    63→	output := transpileCompileRun(t, occam)
    64→	expected := "42\n"
    65→	if output != expected {
    66→		t.Errorf("expected %q, got %q", expected, output)
    67→	}
    68→}
    69→
    70→func TestE2E_VariantProtocolNoPayload(t *testing.T) {
    71→	// Variant protocol with no-payload tag
    72→	occam := `PROTOCOL MSG
    73→  CASE
    74→    data; INT
    75→    quit
    76→
    77→SEQ
    78→  CHAN OF MSG c:
    79→  INT result:
    80→  result := 0

148:func TestE2E_CaseBasic(t *testing.T) {
167:func TestE2E_CaseElse(t *testing.T) {
186:func TestE2E_CaseExpression(t *testing.T) {
224:func TestE2E_MultiStatementCaseBody(t *testing.T) {

   167→func TestE2E_CaseElse(t *testing.T) {
   168→	occam := `SEQ
   169→  INT x:
   170→  x := 99
   171→  CASE x
   172→    1
   173→      print.int(10)
   174→    2
   175→      print.int(20)
   176→    ELSE
   177→      print.int(0)
   178→`
   179→	output := transpileCompileRun(t, occam)
   180→	expected := "0\n"
   181→	if output != expected {
   182→		t.Errorf("expected %q, got %q", expected, output)
   183→	}
   184→}
   185→
   186→func TestE2E_CaseExpression(t *testing.T) {
   187→	occam := `SEQ
   188→  INT x:
   189→  x := 3
   190→  CASE x + 1
   191→    3

codegen/e2e_misc_test.go:145:func TestE2E_AltWithBooleanGuard(t *testing.T) {
codegen/e2e_misc_test.go:170:func TestE2E_AltWithTrueGuard(t *testing.T) {
codegen/e2e_concurrency_test.go:80:func TestE2E_AltBasic(t *testing.T) {
codegen/e2e_concurrency_test.go:101:func TestE2E_AltSecondChannel(t *testing.T) {
codegen/e2e_concurrency_test.go:122:func TestE2E_AltWithBody(t *testing.T) {
codegen/e2e_concurrency_test.go:161:func TestE2E_TimerAltTimeout(t *testing.T) {
codegen/e2e_concurrency_test.go:268:func TestE2E_ReplicatedAltBasic(t *testing.T) {
codegen/e2e_concurrency_test.go:288:func TestE2E_ReplicatedAltIndex(t *testing.T) {
codegen/e2e_concurrency_test.go:312:func TestE2E_ReplicatedAltWithAbbreviation(t *testing.T) {
codegen/e2e_concurrency_test.go:333:func TestE2E_ReplicatedAltByte(t *testing.T) {
codegen/e2e_array_test.go:122:func TestE2E_ChanArrayAlt(t *testing.T) {

     1→package codegen
     2→
     3→import "testing"
     4→
     5→func TestE2E_SimpleProtocol(t *testing.T) {

  155 /home/david/projects/code-associates/occam2go/codegen/e2e_protocol_test.go
  377 /home/david/projects/code-associates/occam2go/codegen/e2e_control_test.go
  355 /home/david/projects/code-associates/occam2go/codegen/e2e_concurrency_test.go
  682 /home/david/projects/code-associates/occam2go/codegen/e2e_misc_test.go
 1569 total

   145→  PAR
   146→    sender(c)
   147→    c ? a ; b
   148→  print.int(a + b)
   149→`
   150→	output := transpileCompileRun(t, occam)
   151→	expected := "10\n"
   152→	if output != expected {
   153→		t.Errorf("expected %q, got %q", expected, output)
   154→	}
   155→}
   156→

   370→      print.int(result)
   371→`
   372→	output := transpileCompileRun(t, occam)
   373→	expected := "11\n"
   374→	if output != expected {
   375→		t.Errorf("expected %q, got %q", expected, output)
   376→	}
   377→}
   378→

   670→
   671→	vetCmd := exec.Command("go", "vet", goFile)
   672→	vetOutput, err := vetCmd.CombinedOutput()
   673→	if err != nil {
   674→		t.Fatalf("go vet failed: %v\nOutput: %s\nGo code:\n%s", err, vetOutput, goCode)
   675→	}
   676→
   677→	// Also verify it runs correctly
   678→	output := transpileCompileRun(t, occamSource)
   679→	if strings.TrimSpace(output) != "42" {
   680→		t.Errorf("expected 42, got %q", output)
   681→	}
   682→}
   683→

The file /home/david/projects/code-associates/occam2go/codegen/e2e_protocol_test.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/e2e_control_test.go has been updated successfully.

   145→func TestE2E_AltWithBooleanGuard(t *testing.T) {
   146→	// ALT with boolean guard: FALSE guard disables a channel
   147→	// Only send on c2 since c1's guard is FALSE and won't be selected
   148→	occam := `SEQ
   149→  CHAN OF INT c1:
   150→  CHAN OF INT c2:
   151→  INT result:
   152→  BOOL allow:
   153→  allow := FALSE
   154→  PAR
   155→    c2 ! 42
   156→    ALT
   157→      allow & c1 ? result
   158→        SKIP
   159→      TRUE & c2 ? result
   160→        SKIP
   161→  print.int(result)
   162→`
   163→	output := transpileCompileRun(t, occam)
   164→	expected := "42\n"
   165→	if output != expected {
   166→		t.Errorf("expected %q, got %q", expected, output)
   167→	}
   168→}
   169→
   170→func TestE2E_AltWithTrueGuard(t *testing.T) {
   171→	// ALT where guard evaluates to TRUE for the first channel
   172→	occam := `SEQ
   173→  CHAN OF INT c:
   174→  INT result:
   175→  PAR
   176→    c ! 99
   177→    ALT
   178→      TRUE & c ? result
   179→        print.int(result)
   180→`
   181→	output := transpileCompileRun(t, occam)
   182→	expected := "99\n"
   183→	if output != expected {
   184→		t.Errorf("expected %q, got %q", expected, output)
   185→	}
   186→}
   187→
   188→func TestE2E_MostNegReal32(t *testing.T) {
   189→	// MOSTNEG REAL32 → -math.MaxFloat32 (a very large negative number)
   190→	occam := `SEQ
   191→  REAL32 x:
   192→  x := MOSTNEG REAL32
   193→  IF
   194→    x < (REAL32 0)
   195→      print.int(1)
   196→    TRUE
   197→      print.int(0)
   198→`
   199→	output := transpileCompileRun(t, occam)

The file /home/david/projects/code-associates/occam2go/codegen/e2e_misc_test.go has been updated successfully.

  1804→}
  1805→
  1806→func (p *Parser) parseBlockStatements() []ast.Statement {
  1807→	var statements []ast.Statement
  1808→	startLevel := p.indentLevel
  1809→
  1810→	p.nextToken() // move past INDENT
  1811→
  1812→	for !p.curTokenIs(lexer.EOF) {
  1813→		// Skip newlines
  1814→		for p.curTokenIs(lexer.NEWLINE) {
  1815→			p.nextToken()
  1816→		}
  1817→
  1818→		// Handle DEDENT tokens
  1819→		// If we're at a DEDENT and indentLevel has dropped below startLevel,
  1820→		// this DEDENT ends our block - stop parsing
  1821→		// If indentLevel >= startLevel, this DEDENT is from a nested block - skip it
  1822→		for p.curTokenIs(lexer.DEDENT) {
  1823→			if p.indentLevel < startLevel {
  1824→				return statements
  1825→			}
  1826→			p.nextToken() // skip nested block's DEDENT
  1827→		}
  1828→
  1829→		// Skip any more newlines after DEDENT
  1830→		for p.curTokenIs(lexer.NEWLINE) {
  1831→			p.nextToken()
  1832→		}
  1833→
  1834→		if p.curTokenIs(lexer.EOF) {
  1835→			break
  1836→		}
  1837→
  1838→		// Double-check we haven't gone below our level
  1839→		if p.indentLevel < startLevel {
  1840→			break
  1841→		}
  1842→
  1843→		stmt := p.parseStatement()
  1844→		if stmt != nil {
  1845→			statements = append(statements, stmt)
  1846→		}
  1847→
  1848→		// After parsing a statement, we need to advance.
  1849→		// But if we're already at NEWLINE/DEDENT/EOF, the next iteration will handle it.
  1850→		// Only advance if we're still on the last token of the statement.
  1851→		if !p.curTokenIs(lexer.NEWLINE) && !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
  1852→			p.nextToken()
  1853→		}
  1854→	}
  1855→
  1856→	return statements
  1857→}
  1858→
  1859→// parseBodyStatements parses multiple statements inside a branch body
  1860→// (IF choice, CASE choice, ALT case, WHILE). Called after the caller has
  1861→// consumed the INDENT token and advanced into the body.
  1862→// Returns all statements found at this indentation level.
  1863→func (p *Parser) parseBodyStatements() []ast.Statement {
  1864→	var statements []ast.Statement
  1865→	startLevel := p.indentLevel
  1866→
  1867→	for !p.curTokenIs(lexer.EOF) {
  1868→		// Skip newlines
  1869→		for p.curTokenIs(lexer.NEWLINE) {
  1870→			p.nextToken()
  1871→		}
  1872→
  1873→		// Handle DEDENT tokens

142:func (p *Parser) ParseProgram() *ast.Program {
143-	program := &ast.Program{}
144-	program.Statements = []ast.Statement{}
145-
146-	for !p.curTokenIs(lexer.EOF) {
147-		stmt := p.parseStatement()
148-		if stmt != nil {
149-			program.Statements = append(program.Statements, stmt)
150-		}
151-		p.nextToken()
152-	}
153-
154-	return program
155-}
156-
157-func (p *Parser) parseStatement() ast.Statement {
158-	// Skip newlines
159-	for p.curTokenIs(lexer.NEWLINE) {
160-		p.nextToken()
161-	}
162-
163-	switch p.curToken.Type {
164-	case lexer.VAL:
165-		return p.parseAbbreviation()
166-	case lexer.INITIAL:
167-		return p.parseInitialDecl()
168-	case lexer.INT_TYPE, lexer.BYTE_TYPE, lexer.BOOL_TYPE, lexer.REAL_TYPE, lexer.REAL32_TYPE, lexer.REAL64_TYPE,
169-		lexer.INT16_TYPE, lexer.INT32_TYPE, lexer.INT64_TYPE:
170-		if p.peekTokenIs(lexer.FUNCTION) || p.peekTokenIs(lexer.FUNC) || p.peekTokenIs(lexer.COMMA) || p.peekTokenIs(lexer.INLINE) {
171-			return p.parseFuncDecl()
172-		}
173-		return p.parseVarDeclOrAbbreviation()
174-	case lexer.LBRACKET:
175-		return p.parseArrayDecl()
176-	case lexer.CHAN:
177-		return p.parseChanDecl()
178-	case lexer.PROTOCOL:
179-		return p.parseProtocolDecl()
180-	case lexer.RECORD:
181-		return p.parseRecordDecl()
182-	case lexer.TIMER:
183-		return p.parseTimerDecl()
184-	case lexer.SEQ:
185-		return p.parseSeqBlock()
186-	case lexer.PAR:
187-		return p.parseParBlock()
188-	case lexer.ALT:
189-		return p.parseAltBlock()
190-	case lexer.SKIP:
191-		return &ast.Skip{Token: p.curToken}
192-	case lexer.STOP:

   980→
   981→		if p.curTokenIs(lexer.EOF) {
   982→			break
   983→		}
   984→
   985→		if p.indentLevel < startLevel {
   986→			break
   987→		}
   988→
   989→		// Parse variant: tag [; TYPE]*
   990→		if !p.curTokenIs(lexer.IDENT) {
   991→			p.addError(fmt.Sprintf("expected variant tag name, got %s", p.curToken.Type))
   992→			return variants
   993→		}
   994→
   995→		v := ast.ProtocolVariant{
   996→			Tag: p.curToken.Literal,
   997→		}
   998→
   999→		// Parse optional types after semicolons
  1000→		for p.peekTokenIs(lexer.SEMICOLON) {
  1001→			p.nextToken() // move to ;
  1002→			p.nextToken() // move past ;
  1003→			typeName := p.parseProtocolTypeName()
  1004→			if typeName == "" {
  1005→				return variants
  1006→			}
  1007→			v.Types = append(v.Types, typeName)
  1008→		}
  1009→

  1008→		}
  1009→
  1010→		variants = append(variants, v)
  1011→
  1012→		// Advance past newline if needed
  1013→		if !p.curTokenIs(lexer.NEWLINE) && !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
  1014→			p.nextToken()
  1015→		}
  1016→	}
  1017→
  1018→	return variants
  1019→}
  1020→
  1021→func (p *Parser) parseRecordDecl() *ast.RecordDecl {
  1022→	decl := &ast.RecordDecl{Token: p.curToken}

227-	case lexer.INDENT, lexer.DEDENT, lexer.EOF:
228-		return nil
229:	default:
230:		p.addError(fmt.Sprintf("unexpected token: %s", p.curToken.Type))
231-		return nil
232-	}
--
937-	case lexer.IDENT:
938-		return p.curToken.Literal
939:	default:
940-		p.addError(fmt.Sprintf("expected type name in protocol, got %s", p.curToken.Type))
941-		return ""
--
2397-			case '\'':
2398-				buf.WriteByte('\'')
2399:			default:
2400-				/ Unknown escape: pass through as-is
2401-				buf.WriteByte('*')
--
2434-		case '"':

[Showing results with pagination = limit: 20, offset: 0]

98:func (p *Parser) nextToken() {
99-	p.curToken = p.peekToken
100-	p.peekToken = p.l.NextToken()
101-
102-	// Track indentation level
103-	if p.curToken.Type == lexer.INDENT {
104-		p.indentLevel++
105-	} else if p.curToken.Type == lexer.DEDENT {
106-		p.indentLevel--
107-	}
108-}
109-
110-func (p *Parser) curTokenIs(t lexer.TokenType) bool {
111-	return p.curToken.Type == t
112-}
113-
114-func (p *Parser) peekTokenIs(t lexer.TokenType) bool {
115-	return p.peekToken.Type == t
116-}
117-
118-func (p *Parser) expectPeek(t lexer.TokenType) bool {

   861→		if p.peekTokenIs(lexer.INDENT) {
   862→			p.nextToken() // consume INDENT
   863→			p.nextToken() // move into block
   864→
   865→			if p.curTokenIs(lexer.CASE) {
   866→				// Variant protocol
   867→				decl.Kind = "variant"
   868→				decl.Variants = p.parseProtocolVariants()
   869→				// Optionally consume trailing colon terminator
   870→				if p.peekTokenIs(lexer.COLON) {
   871→					p.nextToken()
   872→				}
   873→				p.protocolNames[decl.Name] = true
   874→				p.protocolDefs[decl.Name] = decl
   875→				return decl
   876→			}
   877→		}
   878→
   879→		p.addError("expected IS or CASE in protocol declaration")
   880→		return nil

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

  1764→	if hasGuards {
  1765→		// Generate channel variables for guarded cases
  1766→		for i, c := range alt.Cases {
  1767→			if c.Guard != nil {
  1768→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1769→				g.write(fmt.Sprintf("var _alt%d chan ", i))
  1770→				// We don't know the channel type here, so use interface{}
  1771→				// Actually, we should use the same type as the original channel
  1772→				// For now, let's just reference the original channel conditionally
  1773→				g.write(fmt.Sprintf("int = nil\n")) // Assuming int for now
  1774→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1775→				g.write(fmt.Sprintf("if "))
  1776→				g.generateExpression(c.Guard)
  1777→				g.write(fmt.Sprintf(" { _alt%d = %s }\n", i, goIdent(c.Channel)))
  1778→			}
  1779→		}
  1780→	}
  1781→
  1782→	g.writeLine("select {")
  1783→	for i, c := range alt.Cases {
  1784→		g.builder.WriteString(strings.Repeat("\t", g.indent))
  1785→		if c.IsSkip {
  1786→			g.write("default:\n")
  1787→		} else if c.IsTimer {
  1788→			g.write("case <-time.After(time.Duration(")

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

164-	case lexer.VAL:
165:		return p.parseAbbreviation()
166-	case lexer.INITIAL:
--
315-
316:// parseAbbreviation parses VAL abbreviations:
317-/   VAL INT x IS expr:          (typed VAL abbreviation)
--
322-// Current token is VAL.
323:func (p *Parser) parseAbbreviation() ast.Statement {
324-	token := p.curToken // VAL token

   316→// parseAbbreviation parses VAL abbreviations:
   317→//   VAL INT x IS expr:          (typed VAL abbreviation)
   318→//   VAL []BYTE x IS "string":   (open array abbreviation)
   319→//   VAL x IS expr:              (untyped VAL abbreviation)
   320→//   VAL INT X RETYPES X :       (RETYPES declaration)
   321→//   VAL [n]INT X RETYPES X :    (array RETYPES declaration)
   322→// Current token is VAL.
   323→func (p *Parser) parseAbbreviation() ast.Statement {
   324→	token := p.curToken // VAL token
   325→
   326→	p.nextToken()
   327→
   328→	// Check for []TYPE (open array abbreviation)
   329→	isOpenArray := false
   330→	if p.curTokenIs(lexer.LBRACKET) && p.peekTokenIs(lexer.RBRACKET) {
   331→		isOpenArray = true
   332→		p.nextToken() // consume ]
   333→		p.nextToken() // move to type
   334→	}
   335→
   336→	// Check for [n]TYPE (fixed-size array, used in RETYPES)
   337→	isArray := false
   338→	var arraySize ast.Expression
   339→	if !isOpenArray && p.curTokenIs(lexer.LBRACKET) {
   340→		// Could be [n]TYPE name RETYPES ...
   341→		isArray = true
   342→		p.nextToken() // move past [
   343→		arraySize = p.parseExpression(LOWEST)
   344→		if !p.expectPeek(lexer.RBRACKET) {
   345→			return nil
   346→		}
   347→		p.nextToken() // move to type
   348→	}
   349→
   350→	// Check for untyped VAL abbreviation: VAL name IS expr :
   351→	// Detect: curToken is IDENT and peekToken is IS (no type keyword)
   352→	if !isOpenArray && !isArray && p.curTokenIs(lexer.IDENT) && p.peekTokenIs(lexer.IS) {
   353→		name := p.curToken.Literal
   354→		p.nextToken() // consume IS
   355→		p.nextToken() // move to expression
   356→		value := p.parseExpression(LOWEST)
   357→		if !p.expectPeek(lexer.COLON) {
   358→			return nil
   359→		}
   360→		return &ast.Abbreviation{
   361→			Token: token,
   362→			IsVal: true,
   363→			Type:  "",
   364→			Name:  name,
   365→			Value: value,
   366→		}
   367→	}
   368→
   369→	// Expect a type keyword
   370→	if !isTypeToken(p.curToken.Type) {
   371→		p.addError(fmt.Sprintf("expected type after VAL, got %s", p.curToken.Type))
   372→		return nil
   373→	}
   374→	typeName := p.curToken.Literal
   375→
   376→	// Expect name
   377→	if !p.expectPeek(lexer.IDENT) {
   378→		return nil
   379→	}
   380→	name := p.curToken.Literal
   381→
   382→	// Check for RETYPES (instead of IS)
   383→	if p.peekTokenIs(lexer.RETYPES) {
   384→		p.nextToken() // consume RETYPES
   385→		if !p.expectPeek(lexer.IDENT) {
   386→			return nil
   387→		}
   388→		source := p.curToken.Literal
   389→		if !p.expectPeek(lexer.COLON) {
   390→			return nil
   391→		}
   392→		return &ast.RetypesDecl{
   393→			Token:      token,
   394→			IsVal:      true,
   395→			TargetType: typeName,

   396→			IsArray:    isArray,
   397→			ArraySize:  arraySize,
   398→			Name:       name,
   399→			Source:      source,
   400→		}
   401→	}
   402→
   403→	// Expect IS
   404→	if !p.expectPeek(lexer.IS) {
   405→		return nil
   406→	}
   407→
   408→	// Parse expression
   409→	p.nextToken()
   410→	value := p.parseExpression(LOWEST)
   411→
   412→	// Expect colon
   413→	if !p.expectPeek(lexer.COLON) {
   414→		return nil
   415→	}
   416→
   417→	return &ast.Abbreviation{
   418→		Token:       token,
   419→		IsVal:       true,
   420→		IsOpenArray: isOpenArray,
   421→		Type:        typeName,
   422→		Name:        name,
   423→		Value:       value,
   424→	}
   425→}
   426→
   427→// parseInitialDecl parses an INITIAL declaration: INITIAL INT x IS expr:
   428→// Current token is INITIAL.
   429→func (p *Parser) parseInitialDecl() *ast.Abbreviation {
   430→	token := p.curToken // INITIAL token
   431→
   432→	// Expect a type keyword
   433→	p.nextToken()
   434→	if !p.curTokenIs(lexer.INT_TYPE) && !p.curTokenIs(lexer.BYTE_TYPE) &&
   435→		!p.curTokenIs(lexer.BOOL_TYPE) && !p.curTokenIs(lexer.REAL_TYPE) &&
   436→		!p.curTokenIs(lexer.REAL32_TYPE) && !p.curTokenIs(lexer.REAL64_TYPE) {
   437→		p.addError(fmt.Sprintf("expected type after INITIAL, got %s", p.curToken.Type))
   438→		return nil
   439→	}
   440→	typeName := p.curToken.Literal
   441→
   442→	// Expect name
   443→	if !p.expectPeek(lexer.IDENT) {
   444→		return nil
   445→	}

490:type Abbreviation struct {
491-	Token       lexer.Token // VAL, INITIAL, or type token
492-	IsVal       bool        // true for VAL abbreviations
493-	IsInitial   bool        // true for INITIAL declarations
494-	IsOpenArray bool        // true for []TYPE abbreviations (e.g. VAL []BYTE)
495-	Type        string      // "INT", "BYTE", "BOOL", etc.
496-	Name        string      // variable name
497-	Value       Expression  // the expression
498-}
499-
500-func (a *Abbreviation) statementNode()       {}
501-func (a *Abbreviation) TokenLiteral() string { return a.Token.Literal }
502-
503-/ ArrayLiteral represents an array literal expression: [expr1, expr2, ...]
504-type ArrayLiteral struct {
505-	Token    lexer.Token  // the [ token

The file /home/david/projects/code-associates/occam2go/codegen/e2e_misc_test.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/e2e_misc_test.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/e2e_misc_test.go has been updated successfully.

=== RUN   TestE2E_CaseCommaValues
--- PASS: TestE2E_CaseCommaValues (0.08s)
=== RUN   TestE2E_CaseCommaValuesElse
--- PASS: TestE2E_CaseCommaValuesElse (0.08s)
=== RUN   TestE2E_AltWithParenthesizedGuard
--- PASS: TestE2E_AltWithParenthesizedGuard (0.08s)
=== RUN   TestE2E_AltGuardedSkip
--- PASS: TestE2E_AltGuardedSkip (0.08s)
=== RUN   TestE2E_MultiLineAbbreviation
--- PASS: TestE2E_MultiLineAbbreviation (0.08s)
=== RUN   TestE2E_MultiLineAbbreviationExpr
--- PASS: TestE2E_MultiLineAbbreviationExpr (0.08s)
=== RUN   TestE2E_ProtocolTrailingColon
--- PASS: TestE2E_ProtocolTrailingColon (0.08s)
=== RUN   TestE2E_VariantProtocolTrailingColon
--- PASS: TestE2E_VariantProtocolTrailingColon (0.08s)
PASS
ok  	github.com/codeassociates/occam2go/codegen	0.658s

?   	github.com/codeassociates/occam2go	[no test files]
?   	github.com/codeassociates/occam2go/ast	[no test files]
ok  	github.com/codeassociates/occam2go/codegen	18.281s
ok  	github.com/codeassociates/occam2go/lexer	(cached)
ok  	github.com/codeassociates/occam2go/modgen	(cached)
ok  	github.com/codeassociates/occam2go/parser	0.002s
ok  	github.com/codeassociates/occam2go/preproc	(cached)

Parse errors:
  historical-examples/life.occ:43: expected type after [], got [
  historical-examples/life.occ:43: expected ), got ]
  historical-examples/life.occ:43: unexpected token: ]
  historical-examples/life.occ:43: unexpected token in expression: ]
  historical-examples/life.occ:43: expected ], got CHAN
  historical-examples/life.occ:43: expected IDENT, got VAL
  historical-examples/life.occ:44: expected IS, got ,
  historical-examples/life.occ:44: unexpected token: ,
  historical-examples/life.occ:44: unexpected token: )
  historical-examples/life.occ:46: expected :=, !, or ? after link[...], got [
  historical-examples/life.occ:46: expected type after array size, got [
  historical-examples/life.occ:46: unexpected token: ]
  historical-examples/life.occ:46: unexpected token: !
  historical-examples/life.occ:47: unexpected token: :
  historical-examples/life.occ:49: expected type after [], got [
  historical-examples/life.occ:49: expected ), got ]
  historical-examples/life.occ:49: unexpected token: ]
  historical-examples/life.occ:49: unexpected token in expression: ]
  historical-examples/life.occ:49: expected ], got CHAN
  historical-examples/life.occ:49: expected IDENT, got VAL
  historical-examples/life.occ:50: expected IS, got ,
  historical-examples/life.occ:50: unexpected token: ,
  historical-examples/life.occ:51: unexpected token: )
  historical-examples/life.occ:57: expected :=, !, or ? after link[...], got [
  historical-examples/life.occ:57: expected type after array size, got [
  historical-examples/life.occ:57: unexpected token: ]
  historical-examples/life.occ:57: unexpected token: ?
  historical-examples/life.occ:57: expected :=, !, or ? after state.of.neighbour[...], got NEWLINE
  historical-examples/life.occ:74: unexpected token: :
  historical-examples/life.occ:90: expected type after [], got [
  historical-examples/life.occ:90: expected ), got ]
  historical-examples/life.occ:90: unexpected token: ]
  historical-examples/life.occ:90: unexpected token in expression: ]
  historical-examples/life.occ:90: expected ], got CHAN
  historical-examples/life.occ:90: expected IDENT, got VAL
  historical-examples/life.occ:91: expected IS, got ,
  historical-examples/life.occ:91: unexpected token: ,
  historical-examples/life.occ:91: unexpected token in expression: ]
  historical-examples/life.occ:91: expected ], got INT
  historical-examples/life.occ:91: expected IDENT, got CHAN
  historical-examples/life.occ:92: expected IDENT, got CHAN
  historical-examples/life.occ:93: expected :, got )
  historical-examples/life.occ:93: unexpected token: )
  historical-examples/life.occ:106: expected variant tag name, got SEQ
  historical-examples/life.occ:107: expected variant tag name, got INDENT
  historical-examples/life.occ:107: expected variant tag name, got PAR
  historical-examples/life.occ:108: expected variant tag name, got INDENT
  historical-examples/life.occ:108: expected variant tag name, got (
  historical-examples/life.occ:108: expected variant tag name, got ,
  historical-examples/life.occ:108: expected variant tag name, got ,
  historical-examples/life.occ:108: expected variant tag name, got ,
  historical-examples/life.occ:108: expected variant tag name, got )
  historical-examples/life.occ:109: expected variant tag name, got SEQ
  historical-examples/life.occ:110: expected variant tag name, got INDENT
  historical-examples/life.occ:110: expected variant tag name, got (
  historical-examples/life.occ:110: expected variant tag name, got ,
  historical-examples/life.occ:110: expected variant tag name, got ,
  historical-examples/life.occ:110: expected variant tag name, got ,
  historical-examples/life.occ:111: expected variant tag name, got ,
  historical-examples/life.occ:111: expected variant tag name, got )
  historical-examples/life.occ:112: expected variant tag name, got !
  historical-examples/life.occ:112: expected variant tag name, got (
  historical-examples/life.occ:112: expected variant tag name, got <>
  historical-examples/life.occ:112: expected variant tag name, got )
  historical-examples/life.occ:112: expected variant tag name, got ;
  historical-examples/life.occ:113: expected variant tag name, got :=
  historical-examples/life.occ:117: unexpected token: :
  historical-examples/life.occ:213: expected type after [], got [
  historical-examples/life.occ:213: expected ), got ]
  historical-examples/life.occ:213: unexpected token: ]
  historical-examples/life.occ:213: expected IDENT, got [
  historical-examples/life.occ:214: unexpected token in expression: ]
  historical-examples/life.occ:214: expected ], got [
  historical-examples/life.occ:214: unexpected token in expression: ]
  historical-examples/life.occ:214: expected ], got CHAN
  historical-examples/life.occ:214: expected IDENT, got BOOL
  historical-examples/life.occ:215: expected :, got )
  historical-examples/life.occ:215: unexpected token: )
  historical-examples/life.occ:219: expected :=, !, or ? after control[...], got [
  historical-examples/life.occ:219: expected type after array size, got !
  historical-examples/life.occ:225: expected :=, !, or ? after sense[...], got [
  historical-examples/life.occ:225: expected type after array size, got ?
  historical-examples/life.occ:225: unexpected token: ;
  historical-examples/life.occ:233: unexpected token: :
  historical-examples/life.occ:295: expected type after [], got [
  historical-examples/life.occ:295: expected ), got ]
  historical-examples/life.occ:295: unexpected token: ]
  historical-examples/life.occ:295: expected :, got )
  historical-examples/life.occ:295: unexpected token: )
  historical-examples/life.occ:319: expected :=, !, or ? after control[...], got [
  historical-examples/life.occ:319: expected type after array size, got !
  historical-examples/life.occ:319: unexpected token: ;
  historical-examples/life.occ:325: unexpected token: :
  historical-examples/life.occ:350: expected type after [], got [
  historical-examples/life.occ:350: expected ), got ]
  historical-examples/life.occ:350: unexpected token: ]
  historical-examples/life.occ:350: expected IDENT, got [
  historical-examples/life.occ:351: unexpected token in expression: ]
  historical-examples/life.occ:351: expected ], got [
  historical-examples/life.occ:351: unexpected token in expression: ]
  historical-examples/life.occ:351: expected ], got CHAN
  historical-examples/life.occ:351: expected :, got )
  historical-examples/life.occ:351: unexpected token: )
  historical-examples/life.occ:381: expected :=, !, or ? after control[...], got [
  historical-examples/life.occ:381: expected type after array size, got !
  historical-examples/life.occ:383: unexpected token: :
  historical-examples/life.occ:400: expected type after array size, got [
  historical-examples/life.occ:400: unexpected token: ]
  historical-examples/life.occ:401: expected type after array size, got [
  historical-examples/life.occ:401: unexpected token: ]
  historical-examples/life.occ:402: expected type after array size, got [
  historical-examples/life.occ:402: unexpected token: ]
Exit: 1

Updated task #5 status

On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   ast/ast.go
	modified:   codegen/codegen.go
	modified:   codegen/e2e_control_test.go
	modified:   codegen/e2e_misc_test.go
	modified:   codegen/e2e_protocol_test.go
	modified:   lexer/lexer.go
	modified:   parser/parser.go

no changes added to commit (use "git add" and/or "git commit -a")

diff --git a/ast/ast.go b/ast/ast.go
index 5562f2d..496c49f 100644
--- a/ast/ast.go
+++ b/ast/ast.go
@@ -401,6 +401,7 @@ type AltCase struct {
 	Variable     string      // variable to receive into
 	Body         []Statement // the body to execute
 	IsTimer      bool        // true if this is a timer AFTER case
+	IsSkip       bool        // true if this is a guarded SKIP case (guard & SKIP)
 	Timer        string      // timer name (when IsTimer)
 	Deadline     Expression  // AFTER deadline expression (when IsTimer)
 	Declarations []Statement // scoped declarations before channel input (e.g., BYTE ch:)
diff --git a/codegen/codegen.go b/codegen/codegen.go
index dec7efd..e39e4b5 100644
--- a/codegen/codegen.go
+++ b/codegen/codegen.go
@@ -1764,7 +1764,7 @@ func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
 	if hasGuards {
 		// Generate channel variables for guarded cases
 		for i, c := range alt.Cases {
-			if c.Guard != nil {
+			if c.Guard != nil && !c.IsSkip {
 				g.builder.WriteString(strings.Repeat("\t", g.indent))
 				g.write(fmt.Sprintf("var _alt%d chan ", i))
 				// We don't know the channel type here, so use interface{}
@@ -1782,7 +1782,9 @@ func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
 	g.writeLine("select {")
 	for i, c := range alt.Cases {
 		g.builder.WriteString(strings.Repeat("\t", g.indent))
-		if c.IsTimer {
+		if c.IsSkip {
+			g.write("default:\n")
+		} else if c.IsTimer {
 			g.write("case <-time.After(time.Duration(")
 			g.generateExpression(c.Deadline)
 			g.write(" - int(time.Now().UnixMicro())) * time.Microsecond):\n")
diff --git a/codegen/e2e_control_test.go b/codegen/e2e_control_test.go
index e07f032..466cbbb 100644
--- a/codegen/e2e_control_test.go
+++ b/codegen/e2e_control_test.go
@@ -375,3 +375,41 @@ SEQ
 		t.Errorf("expected %q, got %q", expected, output)
 	}
 }
+
+func TestE2E_CaseCommaValues(t *testing.T) {
+	// Issue #75: comma-separated match values in CASE
+	occam := `SEQ
+  INT x:
+  x := 2
+  CASE x
+    1, 2
+      print.int(10)
+    3, 4
+      print.int(20)
+    ELSE
+      print.int(0)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "10\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_CaseCommaValuesElse(t *testing.T) {
+	// Issue #75: ELSE branch with comma-separated values
+	occam := `SEQ
+  INT x:
+  x := 5
+  CASE x
+    1, 2, 3
+      print.int(10)
+    ELSE
+      print.int(99)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "99\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
diff --git a/codegen/e2e_misc_test.go b/codegen/e2e_misc_test.go
index 1553fa4..dadfbb1 100644
--- a/codegen/e2e_misc_test.go
+++ b/codegen/e2e_misc_test.go
@@ -185,6 +185,83 @@ func TestE2E_AltWithTrueGuard(t *testing.T) {
 	}
 }
 
+func TestE2E_AltWithParenthesizedGuard(t *testing.T) {
+	// Issue #78: parenthesized guard expression in ALT
+	occam := `SEQ
+  CHAN OF INT c1:
+  CHAN OF INT c2:
+  INT result:
+  INT mode:
+  mode := 1
+  PAR
+    c2 ! 77
+    ALT
+      (mode <> 1) & c1 ? result
+        SKIP
+      (mode <> 0) & c2 ? result
+        SKIP
+  print.int(result)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "77\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_AltGuardedSkip(t *testing.T) {
+	// Issue #78: guard & SKIP in ALT (always-ready alternative)
+	occam := `SEQ
+  CHAN OF INT c:
+  INT result:
+  BOOL ready:
+  ready := TRUE
+  result := 0
+  PAR
+    SEQ
+      ALT
+        ready & SKIP
+          SKIP
+      c ! 42
+    c ? result
+  print.int(result)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "42\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_MultiLineAbbreviation(t *testing.T) {
+	// Issue #79: IS at end of line as continuation
+	occam := `SEQ
+  VAL INT x IS
+    42 :
+  print.int(x)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "42\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_MultiLineAbbreviationExpr(t *testing.T) {
+	// Issue #79: IS continuation with complex expression
+	occam := `SEQ
+  VAL INT a IS 10 :
+  VAL INT b IS
+    (a + 5) :
+  print.int(b)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "15\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
 func TestE2E_MostNegReal32(t *testing.T) {
 	// MOSTNEG REAL32 → -math.MaxFloat32 (a very large negative number)
 	occam := `SEQ
diff --git a/codegen/e2e_protocol_test.go b/codegen/e2e_protocol_test.go
index 8b51339..900ff95 100644
--- a/codegen/e2e_protocol_test.go
+++ b/codegen/e2e_protocol_test.go
@@ -153,3 +153,50 @@ SEQ
 		t.Errorf("expected %q, got %q", expected, output)
 	}
 }
+
+func TestE2E_ProtocolTrailingColon(t *testing.T) {
+	// Issue #73: trailing colon on protocol declarations
+	occam := `PROTOCOL SIGNAL IS INT :
+PROTOCOL PAIR IS INT ; BOOL :
+
+SEQ
+  CHAN OF SIGNAL c:
+  INT result:
+  PAR
+    c ! 7
+    c ? result
+  print.int(result)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "7\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_VariantProtocolTrailingColon(t *testing.T) {
+	// Issue #73: trailing colon on variant protocol declarations
+	occam := `PROTOCOL MSG
+  CASE
+    data; INT
+    quit
+:
+
+SEQ
+  CHAN OF MSG c:
+  INT result:
+  result := 0
+  PAR
+    c ! data ; 55
+    c ? CASE
+      data ; result
+        print.int(result)
+      quit
+        print.int(0)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "55\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
diff --git a/lexer/lexer.go b/lexer/lexer.go
index c58b185..be7ab24 100644
--- a/lexer/lexer.go
+++ b/lexer/lexer.go
@@ -422,7 +422,8 @@ func isContinuationOp(t TokenType) bool {
 		PLUS_KW, MINUS_KW, TIMES,
 		EQ, NEQ, LT, GT, LE, GE,
 		BITAND, BITOR, BITXOR, LSHIFT, RSHIFT,
-		ASSIGN, AFTER:
+		ASSIGN, AFTER,
+		IS:
 		return true
 	}
 	return false
diff --git a/parser/parser.go b/parser/parser.go
index fdfd62a..7dfa7ac 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -859,6 +859,7 @@ func (p *Parser) parseProtocolDecl() *ast.ProtocolDecl {
 		}
 
 		if p.peekTokenIs(lexer.INDENT) {
+			savedLevel := p.indentLevel
 			p.nextToken() // consume INDENT
 			p.nextToken() // move into block
 
@@ -866,6 +867,14 @@ func (p *Parser) parseProtocolDecl() *ast.ProtocolDecl {
 				// Variant protocol
 				decl.Kind = "variant"
 				decl.Variants = p.parseProtocolVariants()
+				// Consume remaining DEDENTs back to the level before the INDENT
+				for p.peekTokenIs(lexer.DEDENT) && p.indentLevel > savedLevel {
+					p.nextToken()
+				}
+				// Optionally consume trailing colon terminator
+				if p.peekTokenIs(lexer.COLON) {
+					p.nextToken()
+				}
 				p.protocolNames[decl.Name] = true
 				p.protocolDefs[decl.Name] = decl
 				return decl
@@ -906,6 +915,11 @@ func (p *Parser) parseProtocolDecl() *ast.ProtocolDecl {
 		decl.Kind = "sequential"
 	}
 
+	// Optionally consume trailing colon terminator
+	if p.peekTokenIs(lexer.COLON) {
+		p.nextToken()
+	}
+
 	p.protocolNames[decl.Name] = true
 	p.protocolDefs[decl.Name] = decl
 	return decl
@@ -1682,19 +1696,20 @@ func (p *Parser) parseAltCase() *ast.AltCase {
 	}
 
 	// Check for guard: expression & channel ? var
-	// For now, we expect: channel ? var (no guard support yet)
-	// or: guard & channel ? var
+	// or: channel ? var (no guard)
+	// or: guard & SKIP
 
-	// First token should be identifier (channel name or guard start)
-	if !p.curTokenIs(lexer.IDENT) && !p.curTokenIs(lexer.TRUE) && !p.curTokenIs(lexer.FALSE) {
+	// First token should be identifier, TRUE/FALSE, or ( for guard expression
+	if !p.curTokenIs(lexer.IDENT) && !p.curTokenIs(lexer.TRUE) && !p.curTokenIs(lexer.FALSE) && !p.curTokenIs(lexer.LPAREN) {
 		p.addError(fmt.Sprintf("expected channel name or guard in ALT case, got %s", p.curToken.Type))
 		return nil
 	}
 
 	// Look ahead to determine if this is a guard or channel
+	// If current is ( then it must be a guard expression
 	// If next token is & then we have a guard
 	// If next token is ? then it's a channel/timer receive
-	if p.peekTokenIs(lexer.RECEIVE) {
+	if p.curTokenIs(lexer.IDENT) && p.peekTokenIs(lexer.RECEIVE) {
 		name := p.curToken.Literal
 		if p.timerNames[name] {
 			// Timer case: tim ? AFTER deadline
@@ -1715,7 +1730,7 @@ func (p *Parser) parseAltCase() *ast.AltCase {
 			}
 			altCase.Variable = p.curToken.Literal
 		}
-	} else if p.peekTokenIs(lexer.LBRACKET) {
+	} else if p.curTokenIs(lexer.IDENT) && p.peekTokenIs(lexer.LBRACKET) {
 		// Indexed channel case: cs[i] ? var
 		name := p.curToken.Literal
 		altCase.Channel = name
@@ -1733,9 +1748,7 @@ func (p *Parser) parseAltCase() *ast.AltCase {
 		}
 		altCase.Variable = p.curToken.Literal
 	} else {
-		// Could be a guard followed by & channel ? var
-		// For simplicity, parse expression until we hit &
-		// For now, only support simple TRUE/FALSE or identifier guards
+		// Guard followed by & channel ? var, or guard & SKIP
 		guard := p.parseExpression(LOWEST)
 		altCase.Guard = guard
 
@@ -1747,30 +1760,34 @@ func (p *Parser) parseAltCase() *ast.AltCase {
 		p.nextToken() // move to &
 		p.nextToken() // move past &
 
-		// Now expect channel ? var or channel[index] ? var
-		if !p.curTokenIs(lexer.IDENT) {
-			p.addError(fmt.Sprintf("expected channel name after guard, got %s", p.curToken.Type))
+		if p.curTokenIs(lexer.SKIP) {
+			// Guarded SKIP: guard & SKIP
+			altCase.IsSkip = true
+		} else if !p.curTokenIs(lexer.IDENT) {
+			p.addError(fmt.Sprintf("expected channel name or SKIP after guard, got %s", p.curToken.Type))
 			return nil
-		}
-		altCase.Channel = p.curToken.Literal
+		} else {
+			// Channel operation after guard
+			altCase.Channel = p.curToken.Literal
 
-		if p.peekTokenIs(lexer.LBRACKET) {
-			// Indexed channel with guard: guard & cs[i] ? var
-			p.nextToken() // move to [
-			p.nextToken() // move past [
-			altCase.ChannelIndex = p.parseExpression(LOWEST)
-			if !p.expectPeek(lexer.RBRACKET) {
-				return nil
+			if p.peekTokenIs(lexer.LBRACKET) {
+				// Indexed channel with guard: guard & cs[i] ? var
+				p.nextToken() // move to [
+				p.nextToken() // move past [
+				altCase.ChannelIndex = p.parseExpression(LOWEST)
+				if !p.expectPeek(lexer.RBRACKET) {
+					return nil
+				}
 			}
-		}
 
-		if !p.expectPeek(lexer.RECEIVE) {
-			return nil
-		}
-		if !p.expectPeek(lexer.IDENT) {
-			return nil
+			if !p.expectPeek(lexer.RECEIVE) {
+				return nil
+			}
+			if !p.expectPeek(lexer.IDENT) {
+				return nil
+			}
+			altCase.Variable = p.curToken.Literal
 		}
-		altCase.Variable = p.curToken.Literal
 	}
 
 	// Skip to next line for the body
@@ -2634,8 +2651,13 @@ func (p *Parser) parseCaseStatement() *ast.CaseStatement {
 		if p.curTokenIs(lexer.ELSE) {
 			choice.IsElse = true
 		} else {
-			// Parse value expression
+			// Parse value expression(s), comma-separated
 			choice.Values = append(choice.Values, p.parseExpression(LOWEST))
+			for p.peekTokenIs(lexer.COMMA) {
+				p.nextToken() // move to ,
+				p.nextToken() // move past ,
+				choice.Values = append(choice.Values, p.parseExpression(LOWEST))
+			}
 		}
 
 		// Skip newlines and expect INDENT for body

9588006 Merge pull request #71 from codeassociates/dboreham/add-life-example
8acee6e Add Conway Life example program from Programming in occam2 for study of transpiler compatibility
25ad300 Merge pull request #69 from codeassociates/fix/dotted-protocol-tags
3145397 Support dotted protocol tags (e.g., bar.data, bar.terminate)
6faf05d Merge pull request #59 from codeassociates/fix/chan-array-dir-params

Switched to a new branch 'fix/life-occ-issues-73-75-78-79'

7 files changed, 220 insertions(+), 32 deletions(-)

remote: 
remote: Create a pull request for 'fix/life-occ-issues-73-75-78-79' on GitHub by visiting:        
remote:      https://github.com/codeassociates/occam2go/pull/new/fix/life-occ-issues-73-75-78-79        
remote: 
To associate-1.github.com:codeassociates/occam2go.git
 * [new branch]      fix/life-occ-issues-73-75-78-79 -> fix/life-occ-issues-73-75-78-79
branch 'fix/life-occ-issues-73-75-78-79' set up to track 'origin/fix/life-occ-issues-73-75-78-79'.

https://github.com/codeassociates/occam2go/pull/80