1→package ast
     2→
     3→import (
     4→	"github.com/codeassociates/occam2go/lexer"
     5→)
     6→
     7→// Node is the base interface for all AST nodes
     8→type Node interface {
     9→	TokenLiteral() string
    10→}
    11→
    12→// Statement represents a statement node
    13→type Statement interface {
    14→	Node
    15→	statementNode()
    16→}
    17→
    18→// Expression represents an expression node
    19→type Expression interface {
    20→	Node
    21→	expressionNode()
    22→}
    23→
    24→// Program is the root node of every AST
    25→type Program struct {
    26→	Statements []Statement
    27→}
    28→
    29→func (p *Program) TokenLiteral() string {
    30→	if len(p.Statements) > 0 {
    31→		return p.Statements[0].TokenLiteral()
    32→	}
    33→	return ""
    34→}
    35→
    36→// VarDecl represents a variable declaration: INT x:
    37→type VarDecl struct {
    38→	Token lexer.Token // the type token (INT, BYTE, BOOL)
    39→	Type  string      // "INT", "BYTE", "BOOL", etc.
    40→	Names []string    // variable names (can declare multiple: INT x, y, z:)
    41→}
    42→
    43→func (v *VarDecl) statementNode()       {}
    44→func (v *VarDecl) TokenLiteral() string { return v.Token.Literal }
    45→
    46→// ArrayDecl represents an array declaration: [5]INT arr:
    47→type ArrayDecl struct {
    48→	Token lexer.Token // the [ token
    49→	Size  Expression  // array size
    50→	Type  string      // element type ("INT", "BYTE", "BOOL", etc.)
    51→	Names []string    // variable names
    52→}
    53→
    54→func (a *ArrayDecl) statementNode()       {}
    55→func (a *ArrayDecl) TokenLiteral() string { return a.Token.Literal }
    56→
    57→// Assignment represents an assignment: x := 5 or arr[i] := 5 or [arr FROM n FOR m] := value
    58→type Assignment struct {
    59→	Token       lexer.Token // the := token
    60→	Name        string      // variable name
    61→	Index       Expression  // optional: index expression for arr[i] := x (nil for simple assignments)
    62→	SliceTarget *SliceExpr  // optional: slice target for [arr FROM n FOR m] := value
    63→	Value       Expression  // the value being assigned
    64→}
    65→
    66→func (a *Assignment) statementNode()       {}
    67→func (a *Assignment) TokenLiteral() string { return a.Token.Literal }
    68→
    69→// MultiAssignTarget represents one target in a multi-assignment.
    70→// Name is always set. Index is non-nil for indexed targets like arr[i].
    71→type MultiAssignTarget struct {
    72→	Name  string     // variable name
    73→	Index Expression // optional: index expression for arr[i] (nil for simple ident)
    74→}
    75→
    76→// MultiAssignment represents a multi-target assignment: a, b := func(x)
    77→type MultiAssignment struct {
    78→	Token   lexer.Token         // the := token
    79→	Targets []MultiAssignTarget // targets on the left side
    80→	Values  []Expression        // expressions on the right side
    81→}
    82→
    83→func (m *MultiAssignment) statementNode()       {}
    84→func (m *MultiAssignment) TokenLiteral() string { return m.Token.Literal }
    85→
    86→// SeqBlock represents a SEQ block (sequential execution)
    87→// If Replicator is non-nil, this is a replicated SEQ (SEQ i = 0 FOR n)
    88→type SeqBlock struct {
    89→	Token      lexer.Token // the SEQ token
    90→	Statements []Statement
    91→	Replicator *Replicator // optional replicator
    92→}
    93→
    94→func (s *SeqBlock) statementNode()       {}
    95→func (s *SeqBlock) TokenLiteral() string { return s.Token.Literal }
    96→
    97→// ParBlock represents a PAR block (parallel execution)
    98→// If Replicator is non-nil, this is a replicated PAR (PAR i = 0 FOR n)
    99→type ParBlock struct {
   100→	Token      lexer.Token // the PAR token
   101→	Statements []Statement
   102→	Replicator *Replicator // optional replicator
   103→}
   104→
   105→func (p *ParBlock) statementNode()       {}
   106→func (p *ParBlock) TokenLiteral() string { return p.Token.Literal }
   107→
   108→// Replicator represents a replication spec: i = start FOR count [STEP step]
   109→type Replicator struct {
   110→	Variable string     // loop variable name
   111→	Start    Expression // start value
   112→	Count    Expression // number of iterations
   113→	Step     Expression // optional step value (nil means step of 1)
   114→}
   115→
   116→// Skip represents the SKIP statement (no-op)
   117→type Skip struct {
   118→	Token lexer.Token
   119→}
   120→
   121→func (s *Skip) statementNode()       {}
   122→func (s *Skip) TokenLiteral() string { return s.Token.Literal }
   123→
   124→// Stop represents the STOP statement (deadlock/halt)
   125→type Stop struct {
   126→	Token lexer.Token
   127→}
   128→
   129→func (s *Stop) statementNode()       {}
   130→func (s *Stop) TokenLiteral() string { return s.Token.Literal }
   131→
   132→// ProcDecl represents a procedure declaration
   133→type ProcDecl struct {
   134→	Token  lexer.Token // the PROC token
   135→	Name   string
   136→	Params []ProcParam
   137→	Body   []Statement // local declarations + body process
   138→}
   139→
   140→func (p *ProcDecl) statementNode()       {}
   141→func (p *ProcDecl) TokenLiteral() string { return p.Token.Literal }
   142→
   143→// ProcParam represents a procedure parameter
   144→type ProcParam struct {
   145→	IsVal        bool   // VAL parameter (pass by value)
   146→	Type         string // INT, BYTE, BOOL, etc.
   147→	Name         string
   148→	IsChan       bool   // true if this is a CHAN OF <type> parameter
   149→	IsChanArray  bool   // true for []CHAN OF TYPE params
   150→	IsOpenArray  bool   // true for []TYPE params (open array)
   151→	ChanElemType string // element type when IsChan (e.g., "INT")
   152→	ChanDir      string // "?" for input, "!" for output, "" for bidirectional
   153→	ArraySize    string // non-empty for fixed-size array params like [2]INT
   154→}
   155→
   156→// ProcCall represents a procedure call
   157→type ProcCall struct {
   158→	Token lexer.Token // the procedure name token
   159→	Name  string
   160→	Args  []Expression
   161→}
   162→
   163→func (p *ProcCall) statementNode()       {}
   164→func (p *ProcCall) TokenLiteral() string { return p.Token.Literal }
   165→
   166→// FuncDecl represents a function declaration (single or multi-result)
   167→type FuncDecl struct {
   168→	Token       lexer.Token    // the return type token
   169→	ReturnTypes []string       // return types: ["INT"], ["INT", "INT"], etc.
   170→	Name        string
   171→	Params      []ProcParam
   172→	Body        []Statement    // local decls + body statements (VALOF form), empty for IS form
   173→	ResultExprs []Expression   // return expressions (from IS or RESULT)
   174→}
   175→
   176→func (f *FuncDecl) statementNode()       {}
   177→func (f *FuncDecl) TokenLiteral() string { return f.Token.Literal }
   178→
   179→// FuncCall represents a function call expression
   180→type FuncCall struct {
   181→	Token lexer.Token // the function name token
   182→	Name  string
   183→	Args  []Expression
   184→}
   185→
   186→func (f *FuncCall) expressionNode()      {}
   187→func (f *FuncCall) TokenLiteral() string { return f.Token.Literal }
   188→
   189→// WhileLoop represents a WHILE loop
   190→type WhileLoop struct {
   191→	Token     lexer.Token // the WHILE token
   192→	Condition Expression
   193→	Body      []Statement
   194→}
   195→
   196→func (w *WhileLoop) statementNode()       {}
   197→func (w *WhileLoop) TokenLiteral() string { return w.Token.Literal }
   198→
   199→// IfStatement represents an IF statement
   200→type IfStatement struct {
   201→	Token      lexer.Token // the IF token
   202→	Choices    []IfChoice
   203→	Replicator *Replicator // optional replicator for IF i = start FOR count
   204→}
   205→
   206→type IfChoice struct {
   207→	Condition Expression
   208→	Body      []Statement
   209→	NestedIf  *IfStatement // non-nil when this choice is a nested/replicated IF
   210→}
   211→
   212→func (i *IfStatement) statementNode()       {}
   213→func (i *IfStatement) TokenLiteral() string { return i.Token.Literal }
   214→
   215→// CaseStatement represents a CASE statement
   216→type CaseStatement struct {
   217→	Token    lexer.Token  // the CASE token
   218→	Selector Expression   // the selector expression
   219→	Choices  []CaseChoice
   220→}
   221→
   222→type CaseChoice struct {
   223→	Values []Expression // nil/empty for ELSE
   224→	IsElse bool
   225→	Body   []Statement
   226→}
   227→
   228→func (c *CaseStatement) statementNode()       {}
   229→func (c *CaseStatement) TokenLiteral() string { return c.Token.Literal }
   230→
   231→// Expressions
   232→
   233→// Identifier represents a variable reference
   234→type Identifier struct {
   235→	Token lexer.Token
   236→	Value string
   237→}
   238→
   239→func (i *Identifier) expressionNode()      {}
   240→func (i *Identifier) TokenLiteral() string { return i.Token.Literal }
   241→
   242→// IntegerLiteral represents an integer literal
   243→type IntegerLiteral struct {
   244→	Token lexer.Token
   245→	Value int64
   246→}
   247→
   248→func (il *IntegerLiteral) expressionNode()      {}
   249→func (il *IntegerLiteral) TokenLiteral() string { return il.Token.Literal }
   250→
   251→// BooleanLiteral represents TRUE or FALSE
   252→type BooleanLiteral struct {
   253→	Token lexer.Token
   254→	Value bool
   255→}
   256→
   257→func (bl *BooleanLiteral) expressionNode()      {}
   258→func (bl *BooleanLiteral) TokenLiteral() string { return bl.Token.Literal }
   259→
   260→// StringLiteral represents a string literal: "hello"
   261→type StringLiteral struct {
   262→	Token lexer.Token
   263→	Value string
   264→}
   265→
   266→func (sl *StringLiteral) expressionNode()      {}
   267→func (sl *StringLiteral) TokenLiteral() string { return sl.Token.Literal }
   268→
   269→// ByteLiteral represents a byte literal: 'A', '*n', etc.
   270→type ByteLiteral struct {
   271→	Token lexer.Token
   272→	Value byte
   273→}
   274→
   275→func (bl *ByteLiteral) expressionNode()      {}
   276→func (bl *ByteLiteral) TokenLiteral() string { return bl.Token.Literal }
   277→
   278→// BinaryExpr represents a binary operation: x + y
   279→type BinaryExpr struct {
   280→	Token    lexer.Token // the operator token
   281→	Left     Expression
   282→	Operator string
   283→	Right    Expression
   284→}
   285→
   286→func (be *BinaryExpr) expressionNode()      {}
   287→func (be *BinaryExpr) TokenLiteral() string { return be.Token.Literal }
   288→
   289→// UnaryExpr represents a unary operation: NOT x, -x
   290→type UnaryExpr struct {
   291→	Token    lexer.Token // the operator token
   292→	Operator string
   293→	Right    Expression
   294→}
   295→
   296→func (ue *UnaryExpr) expressionNode()      {}
   297→func (ue *UnaryExpr) TokenLiteral() string { return ue.Token.Literal }
   298→
   299→// TypeConversion represents a type conversion expression: INT x, BYTE n, etc.
   300→type TypeConversion struct {
   301→	Token      lexer.Token // the type token (INT, BYTE, etc.)
   302→	TargetType string      // "INT", "BYTE", "BOOL", "REAL"
   303→	Expr       Expression  // the expression to convert
   304→}
   305→
   306→func (tc *TypeConversion) expressionNode()      {}
   307→func (tc *TypeConversion) TokenLiteral() string { return tc.Token.Literal }
   308→
   309→// SizeExpr represents a SIZE expression: SIZE arr
   310→type SizeExpr struct {
   311→	Token lexer.Token // the SIZE token
   312→	Expr  Expression  // the array/string expression
   313→}
   314→
   315→func (se *SizeExpr) expressionNode()      {}
   316→func (se *SizeExpr) TokenLiteral() string { return se.Token.Literal }
   317→
   318→// MostExpr represents MOSTNEG/MOSTPOS type expressions: MOSTNEG INT, MOSTPOS BYTE, etc.
   319→type MostExpr struct {
   320→	Token    lexer.Token // the MOSTNEG or MOSTPOS token
   321→	ExprType string      // "INT", "BYTE", "REAL32", "REAL64", etc.
   322→	IsNeg    bool        // true for MOSTNEG, false for MOSTPOS
   323→}
   324→
   325→func (me *MostExpr) expressionNode()      {}
   326→func (me *MostExpr) TokenLiteral() string { return me.Token.Literal }
   327→
   328→// ParenExpr represents a parenthesized expression
   329→type ParenExpr struct {
   330→	Token lexer.Token
   331→	Expr  Expression
   332→}
   333→
   334→func (pe *ParenExpr) expressionNode()      {}
   335→func (pe *ParenExpr) TokenLiteral() string { return pe.Token.Literal }
   336→
   337→// IndexExpr represents an array index expression: arr[i]
   338→type IndexExpr struct {
   339→	Token lexer.Token // the [ token
   340→	Left  Expression  // the array expression
   341→	Index Expression  // the index expression
   342→}
   343→
   344→func (ie *IndexExpr) expressionNode()      {}
   345→func (ie *IndexExpr) TokenLiteral() string { return ie.Token.Literal }
   346→
   347→// ChanDecl represents a channel declaration: CHAN OF INT c: or [n]CHAN OF INT cs:
   348→type ChanDecl struct {
   349→	Token    lexer.Token // the CHAN token
   350→	ElemType string      // the element type (INT, BYTE, etc.)
   351→	Names    []string    // channel names
   352→	IsArray  bool        // true for [n]CHAN OF TYPE
   353→	Size     Expression  // array size when IsArray
   354→}
   355→
   356→func (c *ChanDecl) statementNode()       {}
   357→func (c *ChanDecl) TokenLiteral() string { return c.Token.Literal }
   358→
   359→// Send represents a channel send: c ! x or c ! x ; y or c ! tag ; x
   360→type Send struct {
   361→	Token        lexer.Token  // the ! token
   362→	Channel      string       // channel name
   363→	ChannelIndex Expression   // non-nil for cs[i] ! value
   364→	Value        Expression   // value to send (simple send, backward compat)
   365→	Values       []Expression // additional values for sequential sends (c ! x ; y)
   366→	VariantTag   string       // variant tag name for variant sends (c ! tag ; x)
   367→}
   368→
   369→func (s *Send) statementNode()       {}
   370→func (s *Send) TokenLiteral() string { return s.Token.Literal }
   371→
   372→// Receive represents a channel receive: c ? x or c ? x ; y
   373→type Receive struct {
   374→	Token        lexer.Token // the ? token
   375→	Channel      string      // channel name
   376→	ChannelIndex Expression  // non-nil for cs[i] ? x
   377→	Variable     string      // variable to receive into (simple receive)
   378→	Variables    []string    // additional variables for sequential receives (c ? x ; y)
   379→}
   380→
   381→func (r *Receive) statementNode()       {}
   382→func (r *Receive) TokenLiteral() string { return r.Token.Literal }
   383→
   384→// AltBlock represents an ALT block (alternation/select)
   385→type AltBlock struct {
   386→	Token lexer.Token // the ALT token
   387→	Cases []AltCase
   388→}
   389→
   390→func (a *AltBlock) statementNode()       {}
   391→func (a *AltBlock) TokenLiteral() string { return a.Token.Literal }
   392→
   393→// AltCase represents a single case in an ALT block
   394→type AltCase struct {
   395→	Guard        Expression  // optional guard condition (nil if no guard)
   396→	Channel      string      // channel name
   397→	ChannelIndex Expression  // non-nil for cs[i] ? x in ALT
   398→	Variable     string      // variable to receive into
   399→	Body         []Statement // the body to execute
   400→	IsTimer      bool        // true if this is a timer AFTER case
   401→	Timer        string      // timer name (when IsTimer)
   402→	Deadline     Expression  // AFTER deadline expression (when IsTimer)
   403→}
   404→
   405→// TimerDecl represents a timer declaration: TIMER tim:
   406→type TimerDecl struct {
   407→	Token lexer.Token // the TIMER token
   408→	Names []string    // timer variable names
   409→}
   410→
   411→func (td *TimerDecl) statementNode()       {}
   412→func (td *TimerDecl) TokenLiteral() string { return td.Token.Literal }
   413→
   414→// TimerRead represents a timer read: tim ? t
   415→type TimerRead struct {
   416→	Token    lexer.Token // the ? token
   417→	Timer    string      // timer name
   418→	Variable string      // variable to receive time into
   419→}
   420→
   421→func (tr *TimerRead) statementNode()       {}
   422→func (tr *TimerRead) TokenLiteral() string { return tr.Token.Literal }
   423→
   424→// ProtocolDecl represents a protocol declaration
   425→type ProtocolDecl struct {
   426→	Token    lexer.Token       // the PROTOCOL token
   427→	Name     string            // protocol name
   428→	Kind     string            // "simple", "sequential", or "variant"
   429→	Types    []string          // element types (simple: len=1, sequential: len>1)
   430→	Variants []ProtocolVariant // only for Kind="variant"
   431→}
   432→
   433→type ProtocolVariant struct {
   434→	Tag   string   // tag name (e.g., "text", "quit")
   435→	Types []string // associated types (empty for no-payload tags)
   436→}
   437→
   438→func (pd *ProtocolDecl) statementNode()       {}
   439→func (pd *ProtocolDecl) TokenLiteral() string { return pd.Token.Literal }
   440→
   441→// VariantReceive represents a variant protocol receive: c ? CASE ...
   442→type VariantReceive struct {
   443→	Token        lexer.Token // the ? token
   444→	Channel      string
   445→	ChannelIndex Expression // non-nil for cs[i] ? CASE ...
   446→	Cases        []VariantCase
   447→}
   448→
   449→type VariantCase struct {
   450→	Tag       string    // variant tag name
   451→	Variables []string  // variables to bind payload fields
   452→	Body      Statement
   453→}
   454→
   455→func (vr *VariantReceive) statementNode()       {}
   456→func (vr *VariantReceive) TokenLiteral() string { return vr.Token.Literal }
   457→
   458→// RecordDecl represents a record type declaration: RECORD POINT { INT x: INT y: }
   459→type RecordDecl struct {
   460→	Token  lexer.Token   // the RECORD token
   461→	Name   string        // record type name
   462→	Fields []RecordField // named fields
   463→}
   464→
   465→type RecordField struct {
   466→	Type string // "INT", "BYTE", "BOOL", "REAL"
   467→	Name string
   468→}
   469→
   470→func (rd *RecordDecl) statementNode()       {}
   471→func (rd *RecordDecl) TokenLiteral() string { return rd.Token.Literal }
   472→
   473→// SliceExpr represents an array slice: [arr FROM start FOR length]
   474→type SliceExpr struct {
   475→	Token  lexer.Token // the [ token
   476→	Array  Expression  // the array being sliced
   477→	Start  Expression  // start index
   478→	Length Expression  // number of elements
   479→}
   480→
   481→func (se *SliceExpr) expressionNode()      {}
   482→func (se *SliceExpr) TokenLiteral() string { return se.Token.Literal }
   483→
   484→// Abbreviation represents an abbreviation: VAL INT x IS 42:, INT y IS z:, or INITIAL INT x IS 42:
   485→type Abbreviation struct {
   486→	Token       lexer.Token // VAL, INITIAL, or type token
   487→	IsVal       bool        // true for VAL abbreviations
   488→	IsInitial   bool        // true for INITIAL declarations
   489→	IsOpenArray bool        // true for []TYPE abbreviations (e.g. VAL []BYTE)
   490→	Type        string      // "INT", "BYTE", "BOOL", etc.
   491→	Name        string      // variable name
   492→	Value       Expression  // the expression
   493→}
   494→
   495→func (a *Abbreviation) statementNode()       {}
   496→func (a *Abbreviation) TokenLiteral() string { return a.Token.Literal }
   497→
   498→// ArrayLiteral represents an array literal expression: [expr1, expr2, ...]
   499→type ArrayLiteral struct {
   500→	Token    lexer.Token  // the [ token
   501→	Elements []Expression // the elements
   502→}
   503→
   504→func (al *ArrayLiteral) expressionNode()      {}
   505→func (al *ArrayLiteral) TokenLiteral() string { return al.Token.Literal }
   506→
   507→// RetypesDecl represents a RETYPES declaration:
   508→// VAL INT X RETYPES X : or VAL [2]INT X RETYPES X :
   509→type RetypesDecl struct {
   510→	Token      lexer.Token // the VAL token
   511→	IsVal      bool        // always true for now (VAL ... RETYPES ...)
   512→	TargetType string      // "INT", "REAL32", etc.
   513→	IsArray    bool        // true for [n]TYPE
   514→	ArraySize  Expression  // array size when IsArray
   515→	Name       string      // target variable name
   516→	Source     string      // source variable name
   517→}
   518→
   519→func (r *RetypesDecl) statementNode()       {}
   520→func (r *RetypesDecl) TokenLiteral() string { return r.Token.Literal }
   521→

385:type AltBlock struct {
386-	Token lexer.Token // the ALT token
387-	Cases []AltCase
388-}
389-
390-func (a *AltBlock) statementNode()       {}
391-func (a *AltBlock) TokenLiteral() string { return a.Token.Literal }
392-
393-// AltCase represents a single case in an ALT block
394-type AltCase struct {
395-	Guard        Expression  // optional guard condition (nil if no guard)

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

1568:func (p *Parser) parseAltBlock() *ast.AltBlock {

1588:func (p *Parser) parseAltCases() []ast.AltCase {
1640:func (p *Parser) parseAltCase() *ast.AltCase {

1604:func (g *Generator) generateAltBlock(alt *ast.AltBlock) {

1463:func (p *Parser) parseSeqBlock() *ast.SeqBlock {

  1463→func (p *Parser) parseSeqBlock() *ast.SeqBlock {
  1464→	block := &ast.SeqBlock{Token: p.curToken}
  1465→
  1466→	// Check for replicator: SEQ i = start FOR count
  1467→	if p.peekTokenIs(lexer.IDENT) {
  1468→		// Save position to check if it's a replicator
  1469→		p.nextToken() // move to identifier
  1470→		if p.peekTokenIs(lexer.EQ) {
  1471→			// This is a replicator
  1472→			block.Replicator = p.parseReplicator()
  1473→		} else {
  1474→			// Not a replicator, this shouldn't happen in valid Occam
  1475→			// (SEQ followed by identifier at same indentation level)
  1476→			p.addError("unexpected identifier after SEQ")
  1477→			return block
  1478→		}
  1479→	}
  1480→
  1481→	// Skip to next line
  1482→	for p.peekTokenIs(lexer.NEWLINE) {
  1483→		p.nextToken()
  1484→	}
  1485→
  1486→	// Expect INDENT
  1487→	if !p.peekTokenIs(lexer.INDENT) {
  1488→		p.addError("expected indented block after SEQ")
  1489→		return block
  1490→	}
  1491→	p.nextToken() // consume INDENT
  1492→
  1493→	block.Statements = p.parseBlockStatements()
  1494→
  1495→	return block
  1496→}
  1497→
  1498→func (p *Parser) parseParBlock() *ast.ParBlock {
  1499→	block := &ast.ParBlock{Token: p.curToken}
  1500→
  1501→	// Check for replicator: PAR i = start FOR count
  1502→	if p.peekTokenIs(lexer.IDENT) {
  1503→		// Save position to check if it's a replicator
  1504→		p.nextToken() // move to identifier
  1505→		if p.peekTokenIs(lexer.EQ) {
  1506→			// This is a replicator
  1507→			block.Replicator = p.parseReplicator()
  1508→		} else {
  1509→			// Not a replicator, this shouldn't happen in valid Occam
  1510→			// (PAR followed by identifier at same indentation level)
  1511→			p.addError("unexpected identifier after PAR")
  1512→			return block
  1513→		}
  1514→	}
  1515→
  1516→	// Skip to next line
  1517→	for p.peekTokenIs(lexer.NEWLINE) {
  1518→		p.nextToken()
  1519→	}
  1520→
  1521→	// Expect INDENT
  1522→	if !p.peekTokenIs(lexer.INDENT) {
  1523→		p.addError("expected indented block after PAR")
  1524→		return block
  1525→	}
  1526→	p.nextToken() // consume INDENT
  1527→
  1528→	block.Statements = p.parseBlockStatements()
  1529→
  1530→	return block
  1531→}
  1532→
  1533→// parseReplicator parses: variable = start FOR count [STEP step]
  1534→// Assumes the variable identifier has already been consumed and is in curToken
  1535→func (p *Parser) parseReplicator() *ast.Replicator {
  1536→	rep := &ast.Replicator{
  1537→		Variable: p.curToken.Literal,
  1538→	}
  1539→
  1540→	// Expect =
  1541→	if !p.expectPeek(lexer.EQ) {
  1542→		return nil
  1543→	}
  1544→
  1545→	// Parse start expression
  1546→	p.nextToken()
  1547→	rep.Start = p.parseExpression(LOWEST)
  1548→
  1549→	// Expect FOR
  1550→	if !p.expectPeek(lexer.FOR) {
  1551→		return nil
  1552→	}
  1553→
  1554→	// Parse count expression
  1555→	p.nextToken()
  1556→	rep.Count = p.parseExpression(LOWEST)
  1557→
  1558→	// Optional STEP
  1559→	if p.peekTokenIs(lexer.STEP) {
  1560→		p.nextToken() // consume STEP
  1561→		p.nextToken() // move to step expression
  1562→		rep.Step = p.parseExpression(LOWEST)
  1563→	}
  1564→
  1565→	return rep
  1566→}
  1567→
  1568→func (p *Parser) parseAltBlock() *ast.AltBlock {
  1569→	block := &ast.AltBlock{Token: p.curToken}
  1570→
  1571→	// Skip to next line
  1572→	for p.peekTokenIs(lexer.NEWLINE) {
  1573→		p.nextToken()
  1574→	}
  1575→
  1576→	// Expect INDENT
  1577→	if !p.peekTokenIs(lexer.INDENT) {
  1578→		p.addError("expected indented block after ALT")
  1579→		return block
  1580→	}
  1581→	p.nextToken() // consume INDENT
  1582→
  1583→	block.Cases = p.parseAltCases()
  1584→
  1585→	return block
  1586→}
  1587→
  1588→func (p *Parser) parseAltCases() []ast.AltCase {
  1589→	var cases []ast.AltCase
  1590→	startLevel := p.indentLevel
  1591→
  1592→	p.nextToken() // move past INDENT

  1568→func (p *Parser) parseAltBlock() *ast.AltBlock {
  1569→	block := &ast.AltBlock{Token: p.curToken}
  1570→
  1571→	// Skip to next line
  1572→	for p.peekTokenIs(lexer.NEWLINE) {
  1573→		p.nextToken()
  1574→	}
  1575→
  1576→	// Expect INDENT
  1577→	if !p.peekTokenIs(lexer.INDENT) {
  1578→		p.addError("expected indented block after ALT")
  1579→		return block
  1580→	}
  1581→	p.nextToken() // consume INDENT
  1582→
  1583→	block.Cases = p.parseAltCases()
  1584→
  1585→	return block
  1586→}
  1587→
  1588→func (p *Parser) parseAltCases() []ast.AltCase {
  1589→	var cases []ast.AltCase
  1590→	startLevel := p.indentLevel
  1591→
  1592→	p.nextToken() // move past INDENT
  1593→
  1594→	for !p.curTokenIs(lexer.EOF) {
  1595→		// Skip newlines
  1596→		for p.curTokenIs(lexer.NEWLINE) {
  1597→			p.nextToken()
  1598→		}
  1599→
  1600→		// Handle DEDENT tokens
  1601→		for p.curTokenIs(lexer.DEDENT) {
  1602→			if p.indentLevel < startLevel {
  1603→				return cases
  1604→			}
  1605→			p.nextToken()
  1606→		}
  1607→
  1608→		// Skip any more newlines after DEDENT
  1609→		for p.curTokenIs(lexer.NEWLINE) {
  1610→			p.nextToken()
  1611→		}
  1612→
  1613→		if p.curTokenIs(lexer.EOF) {
  1614→			break
  1615→		}
  1616→
  1617→		if p.indentLevel < startLevel {
  1618→			break
  1619→		}
  1620→
  1621→		// Safety guard: record position before parsing to detect no-progress
  1622→		prevToken := p.curToken
  1623→		prevPeek := p.peekToken
  1624→
  1625→		// Parse an ALT case: [guard &] channel ? var
  1626→		altCase := p.parseAltCase()
  1627→		if altCase != nil {
  1628→			cases = append(cases, *altCase)
  1629→		}
  1630→
  1631→		// No-progress guard: if we haven't moved, break to prevent infinite loop
  1632→		if p.curToken == prevToken && p.peekToken == prevPeek {
  1633→			break
  1634→		}
  1635→	}
  1636→
  1637→	return cases
  1638→}
  1639→
  1640→func (p *Parser) parseAltCase() *ast.AltCase {
  1641→	altCase := &ast.AltCase{}
  1642→
  1643→	// Check for guard: expression & channel ? var
  1644→	// For now, we expect: channel ? var (no guard support yet)
  1645→	// or: guard & channel ? var
  1646→
  1647→	// First token should be identifier (channel name or guard start)
  1648→	if !p.curTokenIs(lexer.IDENT) && !p.curTokenIs(lexer.TRUE) && !p.curTokenIs(lexer.FALSE) {
  1649→		p.addError(fmt.Sprintf("expected channel name or guard in ALT case, got %s", p.curToken.Type))
  1650→		return nil
  1651→	}
  1652→
  1653→	// Look ahead to determine if this is a guard or channel
  1654→	// If next token is & then we have a guard
  1655→	// If next token is ? then it's a channel/timer receive
  1656→	if p.peekTokenIs(lexer.RECEIVE) {
  1657→		name := p.curToken.Literal
  1658→		if p.timerNames[name] {
  1659→			// Timer case: tim ? AFTER deadline
  1660→			altCase.IsTimer = true
  1661→			altCase.Timer = name
  1662→			p.nextToken() // move to ?
  1663→			if !p.expectPeek(lexer.AFTER) {
  1664→				return nil
  1665→			}
  1666→			p.nextToken() // move past AFTER
  1667→			altCase.Deadline = p.parseExpression(LOWEST)
  1668→		} else {
  1669→			// Simple case: channel ? var
  1670→			altCase.Channel = name
  1671→			p.nextToken() // move to ?
  1672→			if !p.expectPeek(lexer.IDENT) {
  1673→				return nil
  1674→			}
  1675→			altCase.Variable = p.curToken.Literal
  1676→		}
  1677→	} else if p.peekTokenIs(lexer.LBRACKET) {
  1678→		// Indexed channel case: cs[i] ? var
  1679→		name := p.curToken.Literal
  1680→		altCase.Channel = name
  1681→		p.nextToken() // move to [
  1682→		p.nextToken() // move past [
  1683→		altCase.ChannelIndex = p.parseExpression(LOWEST)
  1684→		if !p.expectPeek(lexer.RBRACKET) {
  1685→			return nil
  1686→		}
  1687→		if !p.expectPeek(lexer.RECEIVE) {
  1688→			return nil
  1689→		}
  1690→		if !p.expectPeek(lexer.IDENT) {
  1691→			return nil
  1692→		}
  1693→		altCase.Variable = p.curToken.Literal
  1694→	} else {
  1695→		// Could be a guard followed by & channel ? var
  1696→		// For simplicity, parse expression until we hit &
  1697→		// For now, only support simple TRUE/FALSE or identifier guards
  1698→		guard := p.parseExpression(LOWEST)
  1699→		altCase.Guard = guard
  1700→
  1701→		// Expect &
  1702→		if !p.peekTokenIs(lexer.AMPERSAND) {
  1703→			p.addError("expected & after guard in ALT case")
  1704→			return nil
  1705→		}
  1706→		p.nextToken() // move to &
  1707→		p.nextToken() // move past &
  1708→
  1709→		// Now expect channel ? var or channel[index] ? var
  1710→		if !p.curTokenIs(lexer.IDENT) {
  1711→			p.addError(fmt.Sprintf("expected channel name after guard, got %s", p.curToken.Type))
  1712→			return nil
  1713→		}
  1714→		altCase.Channel = p.curToken.Literal
  1715→
  1716→		if p.peekTokenIs(lexer.LBRACKET) {
  1717→			// Indexed channel with guard: guard & cs[i] ? var

  1604→func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
  1605→	// ALT becomes Go select statement
  1606→	// For guards, we use a pattern with nil channels
  1607→
  1608→	// Check if any cases have guards
  1609→	hasGuards := false
  1610→	for _, c := range alt.Cases {
  1611→		if c.Guard != nil {
  1612→			hasGuards = true
  1613→			break
  1614→		}
  1615→	}
  1616→
  1617→	if hasGuards {
  1618→		// Generate channel variables for guarded cases
  1619→		for i, c := range alt.Cases {
  1620→			if c.Guard != nil {
  1621→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1622→				g.write(fmt.Sprintf("var _alt%d chan ", i))
  1623→				// We don't know the channel type here, so use interface{}
  1624→				// Actually, we should use the same type as the original channel
  1625→				// For now, let's just reference the original channel conditionally
  1626→				g.write(fmt.Sprintf("int = nil\n")) // Assuming int for now
  1627→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1628→				g.write(fmt.Sprintf("if "))
  1629→				g.generateExpression(c.Guard)
  1630→				g.write(fmt.Sprintf(" { _alt%d = %s }\n", i, goIdent(c.Channel)))
  1631→			}
  1632→		}
  1633→	}
  1634→
  1635→	g.writeLine("select {")
  1636→	for i, c := range alt.Cases {
  1637→		g.builder.WriteString(strings.Repeat("\t", g.indent))
  1638→		if c.IsTimer {
  1639→			g.write("case <-time.After(time.Duration(")
  1640→			g.generateExpression(c.Deadline)
  1641→			g.write(" - int(time.Now().UnixMicro())) * time.Microsecond):\n")
  1642→		} else if c.Guard != nil {
  1643→			g.write(fmt.Sprintf("case %s = <-_alt%d:\n", goIdent(c.Variable), i))
  1644→		} else if c.ChannelIndex != nil {
  1645→			g.write(fmt.Sprintf("case %s = <-%s[", goIdent(c.Variable), goIdent(c.Channel)))
  1646→			g.generateExpression(c.ChannelIndex)
  1647→			g.write("]:\n")
  1648→		} else {
  1649→			g.write(fmt.Sprintf("case %s = <-%s:\n", goIdent(c.Variable), goIdent(c.Channel)))
  1650→		}
  1651→		g.indent++
  1652→		for _, s := range c.Body {
  1653→			g.generateStatement(s)
  1654→		}
  1655→		g.indent--
  1656→	}
  1657→	g.writeLine("}")
  1658→}
  1659→
  1660→func (g *Generator) generateProcDecl(proc *ast.ProcDecl) {
  1661→	// Track reference parameters for this procedure
  1662→	oldRefParams := g.refParams
  1663→	newRefParams := make(map[string]bool)
  1664→	// Inherit parent's ref params for closure captures when nested
  1665→	if g.nestingLevel > 0 {
  1666→		for k, v := range oldRefParams {
  1667→			newRefParams[k] = v
  1668→		}
  1669→	}
  1670→	for _, p := range proc.Params {
  1671→		if !p.IsVal && !p.IsChan && !p.IsChanArray && !p.IsOpenArray && p.ArraySize == "" {
  1672→			newRefParams[p.Name] = true
  1673→		} else {
  1674→			// Own param shadows any inherited ref param with same name
  1675→			delete(newRefParams, p.Name)
  1676→		}
  1677→		// Register chan params with protocol mappings
  1678→		if p.IsChan || p.IsChanArray {
  1679→			if _, ok := g.protocolDefs[p.ChanElemType]; ok {
  1680→				g.chanProtocols[p.Name] = p.ChanElemType
  1681→			}
  1682→		}
  1683→		// Register record-typed params
  1684→		if !p.IsChan {
  1685→			if _, ok := g.recordDefs[p.Type]; ok {
  1686→				g.recordVars[p.Name] = p.Type
  1687→			}
  1688→		}
  1689→	}
  1690→	g.refParams = newRefParams
  1691→
  1692→	// Scan proc body for RETYPES declarations that shadow parameters.
  1693→	// When VAL INT X RETYPES X :, Go can't redeclare X in the same scope,
  1694→	// so we rename the parameter (e.g. X → _rp_X) and let RETYPES declare the original name.
  1695→	oldRenames := g.retypesRenames
  1696→	g.retypesRenames = nil
  1697→	paramNames := make(map[string]bool)
  1698→	for _, p := range proc.Params {
  1699→		paramNames[p.Name] = true
  1700→	}
  1701→	for _, stmt := range proc.Body {
  1702→		if rd, ok := stmt.(*ast.RetypesDecl); ok {
  1703→			if paramNames[rd.Source] && rd.Name == rd.Source {
  1704→				if g.retypesRenames == nil {
  1705→					g.retypesRenames = make(map[string]string)
  1706→				}
  1707→				g.retypesRenames[rd.Name] = "_rp_" + goIdent(rd.Name)
  1708→			}
  1709→		}
  1710→	}
  1711→
  1712→	// Generate function signature
  1713→	params := g.generateProcParams(proc.Params)
  1714→	gName := goIdent(proc.Name)
  1715→	if g.nestingLevel > 0 {
  1716→		// Nested PROC: generate as Go closure
  1717→		g.writeLine(fmt.Sprintf("%s := func(%s) {", gName, params))
  1718→	} else {
  1719→		g.writeLine(fmt.Sprintf("func %s(%s) {", gName, params))
  1720→	}
  1721→	g.indent++
  1722→	g.nestingLevel++
  1723→
  1724→	// Register nested proc/func signatures for this scope so that calls
  1725→	// within this proc resolve to the correct (local) signature rather than
  1726→	// a same-named proc from a different scope.
  1727→	oldSigs := make(map[string][]ast.ProcParam)
  1728→	g.collectNestedProcSigsScoped(proc.Body, oldSigs)
  1729→
  1730→	for _, stmt := range proc.Body {
  1731→		g.generateStatement(stmt)
  1732→	}
  1733→
  1734→	// Restore overwritten signatures
  1735→	for name, params := range oldSigs {
  1736→		if params == nil {
  1737→			delete(g.procSigs, name)
  1738→		} else {
  1739→			g.procSigs[name] = params
  1740→		}
  1741→	}
  1742→
  1743→	g.nestingLevel--
  1744→	g.indent--
  1745→	g.writeLine("}")
  1746→	g.writeLine("")
  1747→
  1748→	// Restore previous context
  1749→	g.refParams = oldRefParams
  1750→	g.retypesRenames = oldRenames
  1751→}
  1752→
  1753→func (g *Generator) generateProcParams(params []ast.ProcParam) string {

  1716→		if p.peekTokenIs(lexer.LBRACKET) {
  1717→			// Indexed channel with guard: guard & cs[i] ? var
  1718→			p.nextToken() // move to [
  1719→			p.nextToken() // move past [
  1720→			altCase.ChannelIndex = p.parseExpression(LOWEST)
  1721→			if !p.expectPeek(lexer.RBRACKET) {
  1722→				return nil
  1723→			}
  1724→		}
  1725→
  1726→		if !p.expectPeek(lexer.RECEIVE) {
  1727→			return nil
  1728→		}
  1729→		if !p.expectPeek(lexer.IDENT) {
  1730→			return nil
  1731→		}
  1732→		altCase.Variable = p.curToken.Literal
  1733→	}
  1734→
  1735→	// Skip to next line for the body
  1736→	for p.peekTokenIs(lexer.NEWLINE) {
  1737→		p.nextToken()
  1738→	}
  1739→
  1740→	// Expect INDENT for body
  1741→	if !p.peekTokenIs(lexer.INDENT) {
  1742→		p.addError("expected indented body after ALT case")
  1743→		return altCase
  1744→	}
  1745→	p.nextToken() // consume INDENT
  1746→	p.nextToken() // move into body
  1747→
  1748→	altCase.Body = p.parseBodyStatements()
  1749→
  1750→	return altCase
  1751→}
  1752→
  1753→func (p *Parser) parseBlockStatements() []ast.Statement {
  1754→	var statements []ast.Statement
  1755→	startLevel := p.indentLevel
  1756→
  1757→	p.nextToken() // move past INDENT
  1758→
  1759→	for !p.curTokenIs(lexer.EOF) {
  1760→		// Skip newlines
  1761→		for p.curTokenIs(lexer.NEWLINE) {
  1762→			p.nextToken()
  1763→		}
  1764→
  1765→		// Handle DEDENT tokens
  1766→		// If we're at a DEDENT and indentLevel has dropped below startLevel,
  1767→		// this DEDENT ends our block - stop parsing
  1768→		// If indentLevel >= startLevel, this DEDENT is from a nested block - skip it
  1769→		for p.curTokenIs(lexer.DEDENT) {
  1770→			if p.indentLevel < startLevel {
  1771→				return statements
  1772→			}
  1773→			p.nextToken() // skip nested block's DEDENT
  1774→		}
  1775→
  1776→		// Skip any more newlines after DEDENT
  1777→		for p.curTokenIs(lexer.NEWLINE) {
  1778→			p.nextToken()
  1779→		}
  1780→
  1781→		if p.curTokenIs(lexer.EOF) {
  1782→			break
  1783→		}
  1784→
  1785→		// Double-check we haven't gone below our level
  1786→		if p.indentLevel < startLevel {
  1787→			break
  1788→		}
  1789→
  1790→		stmt := p.parseStatement()
  1791→		if stmt != nil {
  1792→			statements = append(statements, stmt)
  1793→		}
  1794→
  1795→		// After parsing a statement, we need to advance.

11:type Generator struct {
12-	indent   int
13-	builder  strings.Builder
14-	needSync bool // track if we need sync package import
15-	needFmt  bool // track if we need fmt package import
16-	needTime bool // track if we need time package import
17-	needOs   bool // track if we need os package import
18-	needMath bool // track if we need math package import
19-	needMathBits bool // track if we need math/bits package import
20-	needBufio    bool // track if we need bufio package import
21-
22-	// Track procedure signatures for proper pointer handling
23-	procSigs map[string][]ast.ProcParam
24-	// Track current procedure's reference parameters
25-	refParams map[string]bool
26-
27-	// Protocol support
28-	protocolDefs  map[string]*ast.ProtocolDecl
29-	chanProtocols map[string]string // channel name → protocol name
30-	tmpCounter    int               // for unique temp variable names
31-
32-	// Record support
33-	recordDefs map[string]*ast.RecordDecl
34-	recordVars map[string]string // variable name → record type name
35-
36-	/ Nesting level: 0 = package level, >0 = inside a function
37-	nestingLevel int
38-
39-	/ RETYPES parameter renames: when a RETYPES declaration shadows a
40-	/ parameter (e.g. VAL INT X RETYPES X :), the parameter is renamed
41-	/ in the signature so := can create a new variable with the original name.

108:		if g.containsPar(stmt) {
114:		if g.containsTimer(stmt) {
476:func (g *Generator) containsPar(stmt ast.Statement) bool {
482:			if g.containsPar(inner) {
489:				if g.containsPar(inner) {
496:			if g.containsPar(inner) {
502:			if g.containsPar(inner) {
508:			if g.containsPar(inner) {
515:				if g.containsPar(choice.NestedIf) {
520:				if g.containsPar(inner) {
528:				if g.containsPar(inner) {
535:			if c.Body != nil && g.containsPar(c.Body) {
616:func (g *Generator) containsTimer(stmt ast.Statement) bool {
626:				if g.containsTimer(inner) {
633:			if g.containsTimer(inner) {
639:			if g.containsTimer(inner) {
645:			if g.containsTimer(inner) {
651:			if g.containsTimer(inner) {
657:			if g.containsTimer(inner) {
664:				if g.containsTimer(choice.NestedIf) {
669:				if g.containsTimer(inner) {
677:				if g.containsTimer(inner) {
684:			if c.Body != nil && g.containsTimer(c.Body) {

    42→	retypesRenames map[string]string
    43→}
    44→
    45→// Transputer intrinsic function names
    46→var transpIntrinsics = map[string]bool{
    47→	"LONGPROD":   true,
    48→	"LONGDIV":    true,
    49→	"LONGSUM":    true,
    50→	"LONGDIFF":   true,
    51→	"NORMALISE":  true,
    52→	"SHIFTRIGHT": true,
    53→	"SHIFTLEFT":  true,
    54→}
    55→
    56→// Built-in print procedures
    57→var printBuiltins = map[string]bool{
    58→	"print.int":     true,
    59→	"print.string":  true,
    60→	"print.bool":    true,
    61→	"print.newline": true,
    62→}
    63→
    64→// New creates a new code generator
    65→func New() *Generator {
    66→	return &Generator{}
    67→}
    68→
    69→// goIdent converts an occam identifier to a valid Go identifier.
    70→// Occam allows dots in identifiers (e.g., out.repeat); Go does not.
    71→// goReserved is a set of Go keywords and predeclared identifiers that cannot be
    72→// used as variable names when they also appear as type conversions in the generated code.
    73→var goReserved = map[string]bool{
    74→	"byte": true, "int": true, "string": true, "len": true, "cap": true,
    75→	"make": true, "new": true, "copy": true, "close": true, "delete": true,
    76→	"panic": true, "recover": true, "print": true, "println": true,
    77→	"error": true, "rune": true, "bool": true, "true": true, "false": true,
    78→}
    79→
    80→func goIdent(name string) string {
    81→	name = strings.ReplaceAll(name, ".", "_")
    82→	if goReserved[name] {
    83→		return "_" + name
    84→	}
    85→	return name
    86→}
    87→
    88→// Generate produces Go code from the AST
    89→func (g *Generator) Generate(program *ast.Program) string {
    90→	g.builder.Reset()
    91→	g.needSync = false
    92→	g.needFmt = false
    93→	g.needTime = false
    94→	g.needOs = false
    95→	g.needMath = false
    96→	g.needMathBits = false
    97→	g.needBufio = false
    98→	g.procSigs = make(map[string][]ast.ProcParam)
    99→	g.refParams = make(map[string]bool)
   100→	g.protocolDefs = make(map[string]*ast.ProtocolDecl)
   101→	g.chanProtocols = make(map[string]string)
   102→	g.tmpCounter = 0
   103→	g.recordDefs = make(map[string]*ast.RecordDecl)
   104→	g.recordVars = make(map[string]string)
   105→
   106→	// First pass: collect procedure signatures, protocols, and check for PAR/print
   107→	for _, stmt := range program.Statements {
   108→		if g.containsPar(stmt) {
   109→			g.needSync = true
   110→		}
   111→		if g.containsPrint(stmt) {
   112→			g.needFmt = true
   113→		}
   114→		if g.containsTimer(stmt) {
   115→			g.needTime = true
   116→		}
   117→		if g.containsStop(stmt) {
   118→			g.needOs = true
   119→			g.needFmt = true
   120→		}
   121→		if g.containsMostExpr(stmt) {

    98→	g.procSigs = make(map[string][]ast.ProcParam)
    99→	g.refParams = make(map[string]bool)
   100→	g.protocolDefs = make(map[string]*ast.ProtocolDecl)
   101→	g.chanProtocols = make(map[string]string)
   102→	g.tmpCounter = 0
   103→	g.recordDefs = make(map[string]*ast.RecordDecl)
   104→	g.recordVars = make(map[string]string)
   105→
   106→	// First pass: collect procedure signatures, protocols, and check for PAR/print
   107→	for _, stmt := range program.Statements {
   108→		if g.containsPar(stmt) {
   109→			g.needSync = true
   110→		}
   111→		if g.containsPrint(stmt) {
   112→			g.needFmt = true
   113→		}
   114→		if g.containsTimer(stmt) {
   115→			g.needTime = true
   116→		}
   117→		if g.containsStop(stmt) {
   118→			g.needOs = true
   119→			g.needFmt = true
   120→		}
   121→		if g.containsMostExpr(stmt) {
   122→			g.needMath = true
   123→		}
   124→		if g.containsIntrinsics(stmt) {
   125→			g.needMathBits = true
   126→		}
   127→		if g.containsRetypes(stmt) {
   128→			g.needMath = true
   129→		}
   130→		if proc, ok := stmt.(*ast.ProcDecl); ok {
   131→			g.procSigs[proc.Name] = proc.Params
   132→			g.collectNestedProcSigs(proc.Body)
   133→		}
   134→		if fn, ok := stmt.(*ast.FuncDecl); ok {
   135→			g.procSigs[fn.Name] = fn.Params
   136→		}
   137→		if proto, ok := stmt.(*ast.ProtocolDecl); ok {
   138→			g.protocolDefs[proto.Name] = proto
   139→		}
   140→		if rec, ok := stmt.(*ast.RecordDecl); ok {
   141→			g.recordDefs[rec.Name] = rec
   142→		}
   143→		g.collectChanProtocols(stmt)
   144→		g.collectRecordVars(stmt)
   145→	}
   146→
   147→	// Separate protocol, record, procedure declarations from other statements
   148→	var typeDecls []ast.Statement
   149→	var procDecls []ast.Statement
   150→	var mainStatements []ast.Statement
   151→
   152→	// First pass: check if there are any proc/func declarations
   153→	hasProcDecls := false
   154→	for _, stmt := range program.Statements {
   155→		if _, ok := stmt.(*ast.ProcDecl); ok {
   156→			hasProcDecls = true
   157→			break
   158→		}
   159→		if _, ok := stmt.(*ast.FuncDecl); ok {
   160→			hasProcDecls = true
   161→			break
   162→		}
   163→	}
   164→
   165→	var abbrDecls []ast.Statement
   166→	for _, stmt := range program.Statements {
   167→		switch s := stmt.(type) {
   168→		case *ast.ProtocolDecl, *ast.RecordDecl:
   169→			typeDecls = append(typeDecls, stmt)
   170→		case *ast.ProcDecl, *ast.FuncDecl:
   171→			procDecls = append(procDecls, stmt)
   172→		case *ast.Abbreviation:
   173→			if hasProcDecls {
   174→				// Top-level abbreviations need to be at package level
   175→				// so PROCs can reference them
   176→				abbrDecls = append(abbrDecls, stmt)
   177→			} else {
   178→				mainStatements = append(mainStatements, stmt)
   179→			}
   180→		case *ast.RetypesDecl:
   181→			_ = s
   182→			// RETYPES declarations are local to functions, not package-level
   183→			mainStatements = append(mainStatements, stmt)
   184→		default:
   185→			mainStatements = append(mainStatements, stmt)
   186→		}
   187→	}
   188→
   189→	// Detect entry point PROC so we can set import flags before writing imports
   190→	var entryProc *ast.ProcDecl
   191→	if len(mainStatements) == 0 {
   192→		entryProc = g.findEntryProc(procDecls)
   193→		if entryProc != nil {
   194→			g.needOs = true
   195→			g.needSync = true
   196→			g.needBufio = true
   197→		}
   198→	}
   199→
   200→	// Write package declaration
   201→	g.writeLine("package main")
   202→	g.writeLine("")
   203→
   204→	// Write imports
   205→	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits || g.needBufio {
   206→		g.writeLine("import (")
   207→		g.indent++
   208→		if g.needBufio {
   209→			g.writeLine(`"bufio"`)
   210→		}
   211→		if g.needFmt {
   212→			g.writeLine(`"fmt"`)
   213→		}
   214→		if g.needMath {
   215→			g.writeLine(`"math"`)
   216→		}
   217→		if g.needMathBits {

   217→		if g.needMathBits {
   218→			g.writeLine(`"math/bits"`)
   219→		}
   220→		if g.needOs {
   221→			g.writeLine(`"os"`)
   222→		}
   223→		if g.needSync {
   224→			g.writeLine(`"sync"`)
   225→		}
   226→		if g.needTime {
   227→			g.writeLine(`"time"`)
   228→		}
   229→		g.indent--
   230→		g.writeLine(")")
   231→		g.writeLine("")
   232→	}
   233→
   234→	// Emit transputer intrinsic helper functions
   235→	if g.needMathBits {
   236→		g.emitIntrinsicHelpers()
   237→	}
   238→
   239→	// Generate type definitions first (at package level)
   240→	for _, stmt := range typeDecls {
   241→		g.generateStatement(stmt)
   242→	}
   243→
   244→	// Generate package-level abbreviations (constants)
   245→	for _, stmt := range abbrDecls {
   246→		abbr := stmt.(*ast.Abbreviation)
   247→		if abbr.Type == "" {
   248→			// Untyped VAL: let Go infer the type
   249→			g.builder.WriteString("var ")
   250→			g.write(fmt.Sprintf("%s = ", goIdent(abbr.Name)))
   251→			g.generateExpression(abbr.Value)
   252→			g.write("\n")
   253→		} else {
   254→			goType := g.occamTypeToGo(abbr.Type)
   255→			if abbr.IsOpenArray {
   256→				goType = "[]" + goType

1394:func (g *Generator) occamTypeToGoBase(occamType string) string {
1395-	switch occamType {
1396-	case "INT":
1397-		return "int"
1398-	case "BYTE":
1399-		return "byte"
1400-	case "BOOL":
1401-		return "bool"
1402-	case "REAL":
1403-		return "float64"
1404-	case "REAL32":
1405-		return "float32"
1406-	case "REAL64":
1407-		return "float64"
1408-	default:
1409-		return occamType
1410-	}
1411-}
1412-
1413:func (g *Generator) occamTypeToGo(occamType string) string {
1414-	switch occamType {
1415-	case "INT":
1416-		return "int"
1417-	case "BYTE":
1418-		return "byte"
1419-	case "BOOL":
1420-		return "bool"
1421-	case "REAL":
1422-		return "float64"
1423-	case "REAL32":
1424-		return "float32"
1425-	case "REAL64":
1426-		return "float64"
1427-	default:
1428-		// Check if it's a protocol name
1429-		if _, ok := g.protocolDefs[occamType]; ok {
1430-			return "_proto_" + occamType
1431-		}
1432-		// Check if it's a record type name
1433-		if _, ok := g.recordDefs[occamType]; ok {

978:		g.generateParBlock(s)
1537:func (g *Generator) generateParBlock(par *ast.ParBlock) {

codegen/e2e_array_test.go:122:func TestE2E_ChanArrayAlt(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_misc_test.go:145:func TestE2E_AltWithBooleanGuard(t *testing.T) {
codegen/e2e_misc_test.go:170:func TestE2E_AltWithTrueGuard(t *testing.T) {

  1537→func (g *Generator) generateParBlock(par *ast.ParBlock) {
  1538→	if par.Replicator != nil {
  1539→		// Replicated PAR: PAR i = start FOR count becomes goroutines in a loop
  1540→		g.writeLine("var wg sync.WaitGroup")
  1541→		g.builder.WriteString(strings.Repeat("\t", g.indent))
  1542→		g.write("wg.Add(int(")
  1543→		g.generateExpression(par.Replicator.Count)
  1544→		g.write("))\n")
  1545→
  1546→		v := goIdent(par.Replicator.Variable)
  1547→		if par.Replicator.Step != nil {
  1548→			counter := "_repl_" + v
  1549→			g.builder.WriteString(strings.Repeat("\t", g.indent))
  1550→			g.write(fmt.Sprintf("for %s := 0; %s < ", counter, counter))
  1551→			g.generateExpression(par.Replicator.Count)
  1552→			g.write(fmt.Sprintf("; %s++ {\n", counter))
  1553→			g.indent++
  1554→			// Compute loop variable from counter — also serves as closure capture
  1555→			g.builder.WriteString(strings.Repeat("\t", g.indent))
  1556→			g.write(fmt.Sprintf("%s := ", v))
  1557→			g.generateExpression(par.Replicator.Start)
  1558→			g.write(fmt.Sprintf(" + %s * ", counter))
  1559→			g.generateExpression(par.Replicator.Step)
  1560→			g.write("\n")
  1561→		} else {
  1562→			g.builder.WriteString(strings.Repeat("\t", g.indent))
  1563→			g.write(fmt.Sprintf("for %s := ", v))
  1564→			g.generateExpression(par.Replicator.Start)
  1565→			g.write(fmt.Sprintf("; %s < ", v))
  1566→			g.generateExpression(par.Replicator.Start)
  1567→			g.write(" + ")
  1568→			g.generateExpression(par.Replicator.Count)
  1569→			g.write(fmt.Sprintf("; %s++ {\n", v))
  1570→			g.indent++
  1571→			// Capture loop variable to avoid closure issues
  1572→			g.writeLine(fmt.Sprintf("%s := %s", v, v))
  1573→		}
  1574→		g.writeLine("go func() {")
  1575→		g.indent++
  1576→		g.writeLine("defer wg.Done()")
  1577→		for _, stmt := range par.Statements {
  1578→			g.generateStatement(stmt)
  1579→		}
  1580→		g.indent--
  1581→		g.writeLine("}()")
  1582→
  1583→		g.indent--
  1584→		g.writeLine("}")
  1585→		g.writeLine("wg.Wait()")
  1586→	} else {
  1587→		// PAR becomes goroutines with WaitGroup
  1588→		g.writeLine("var wg sync.WaitGroup")
  1589→		g.writeLine(fmt.Sprintf("wg.Add(%d)", len(par.Statements)))
  1590→
  1591→		for _, stmt := range par.Statements {
  1592→			g.writeLine("go func() {")
  1593→			g.indent++
  1594→			g.writeLine("defer wg.Done()")
  1595→			g.generateStatement(stmt)
  1596→			g.indent--
  1597→			g.writeLine("}()")
  1598→		}
  1599→
  1600→		g.writeLine("wg.Wait()")
  1601→	}
  1602→}
  1603→
  1604→func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
  1605→	// ALT becomes Go select statement
  1606→	// For guards, we use a pattern with nil channels

    80→func TestE2E_AltBasic(t *testing.T) {
    81→	// Test basic ALT: select from first ready channel
    82→	occam := `SEQ
    83→  CHAN OF INT c1:
    84→  CHAN OF INT c2:
    85→  INT result:
    86→  PAR
    87→    c1 ! 42
    88→    ALT
    89→      c1 ? result
    90→        print.int(result)
    91→      c2 ? result
    92→        print.int(result)
    93→`
    94→	output := transpileCompileRun(t, occam)
    95→	expected := "42\n"
    96→	if output != expected {
    97→		t.Errorf("expected %q, got %q", expected, output)
    98→	}
    99→}
   100→
   101→func TestE2E_AltSecondChannel(t *testing.T) {
   102→	// Test ALT selecting from second channel
   103→	occam := `SEQ
   104→  CHAN OF INT c1:
   105→  CHAN OF INT c2:
   106→  INT result:
   107→  PAR
   108→    c2 ! 99
   109→    ALT
   110→      c1 ? result
   111→        print.int(result)
   112→      c2 ? result
   113→        print.int(result)
   114→`
   115→	output := transpileCompileRun(t, occam)
   116→	expected := "99\n"
   117→	if output != expected {
   118→		t.Errorf("expected %q, got %q", expected, output)
   119→	}
   120→}
   121→
   122→func TestE2E_AltWithBody(t *testing.T) {
   123→	// Test ALT with computation in body
   124→	occam := `SEQ
   125→  CHAN OF INT c:
   126→  INT result:
   127→  PAR
   128→    c ! 10
   129→    ALT
   130→      c ? result
   131→        SEQ
   132→          result := result * 2
   133→          print.int(result)
   134→`
   135→	output := transpileCompileRun(t, occam)
   136→	expected := "20\n"
   137→	if output != expected {
   138→		t.Errorf("expected %q, got %q", expected, output)
   139→	}
   140→}
   141→
   142→func TestE2E_TimerRead(t *testing.T) {
   143→	// Test reading a timer: value should be positive (microseconds since epoch)
   144→	occam := `SEQ
   145→  TIMER tim:
   146→  INT t:
   147→  tim ? t
   148→  IF
   149→    t > 0
   150→      print.int(1)
   151→    TRUE
   152→      print.int(0)
   153→`
   154→	output := transpileCompileRun(t, occam)
   155→	expected := "1\n"
   156→	if output != expected {
   157→		t.Errorf("expected %q, got %q", expected, output)
   158→	}
   159→}
   160→
   161→func TestE2E_TimerAltTimeout(t *testing.T) {
   162→	// Test ALT with timer timeout: no channel is ready, so timer fires
   163→	occam := `SEQ
   164→  TIMER tim:

<persisted-output>
Output too large (119.5KB). Full output saved to: /home/david/.claude/projects/-home-david-projects-code-associates-occam2go/e58f8b2d-0746-44e6-abce-4fd17dcc4cb0/tool-results/toolu_012QocmBGMUyiwyDP1LfGWMw.txt

Preview (first 2KB):
kroc/tests/cgtests/cgtest05.occ:371:              ALT I = 0 FOR 40
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-372-                X[I] ? any
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-373-                  SEQ
kroc/tests/cgtests/cgtest05.occ-374-                    B := I
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-375-                    check (I, 33, "AU0")
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-376-            check( A, 0, "AU1")
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-377-            check( B, 33, "AU2")
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-378-            check( any, 0, "AU3")
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-379-        --}}}
--
kroc/tests/cgtests/cgtest05.occ:388:            ALT I = 0 FOR 40
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-389-              X[I] ? any
kroc/tests/cgtests/cgtest05.occ-390-                B := I
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-391-            SEQ
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-392-              SEQ I = 0 FOR 100
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-393-                SEQ
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-394-              X[A + 33] ! (NOT TRUE)
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-395-          check (B, 33, "AU4")
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-396-          check (INT any, INT FALSE, "AU5")
--
kroc/tests/cgtests/cgtest05.occ:414:            ALT I = 0 FOR 30
/home/david/projects/code-associates/occam2go/kroc/tests/cgtests/cgtest05.occ-415-              X[I] ? B
...
</persisted-output>

kroc/modules/course/examples/sort_pump_2.occ:184:      ALT i = 0 FOR n.inputs
kroc/modules/course/examples/sort_pump_2.occ-185-        BYTE ch:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-186-        in[i] ? ch
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-187-          --{{{  lock on to this channel for the whole message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-188-          SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-189-            WHILE ch <> end.message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-190-              SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-191-                --{{{  end.marker --> end.char
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-192-                IF
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ-193-                  ch = end.marker
kroc/modules/course/examples/sort_pump_2.occ-194-                    ch := end.char
--
kroc/modules/course/examples/sort_inside_2.occ:224:      ALT i = 0 FOR n.inputs
kroc/modules/course/examples/sort_inside_2.occ-225-        BYTE ch:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-226-        in[i] ? ch
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-227-          --{{{  lock on to this channel for the whole message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-228-          SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-229-            WHILE ch <> end.message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-230-              SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-231-                --{{{  end.marker --> end.char
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-232-                IF
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-233-                  ch = end.marker
kroc/modules/course/examples/sort_inside_2.occ-234-                    ch := end.char
--
kroc/modules/course/examples/sort_inside_2.occ:294:    ALT i = 0 FOR SIZE monitor?
kroc/modules/course/examples/sort_inside_2.occ-295-      BYTE next, largest:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-296-      monitor[i] ? next
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-297-        SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-298-          monitor[i] ? largest
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-299-          cursor.x.y (3 + ((BYTE i)*5), 3, out!)
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-300-          out ! next
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-301-          out ! largest
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-302-          out ! end.message
kroc/modules/course/examples/sort_inside_2.occ-303-:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ-304---}}}
--
kroc/modules/course/examples/sort_inside.occ:213:      ALT i = 0 FOR n.inputs
kroc/modules/course/examples/sort_inside.occ-214-        BYTE ch:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-215-        in[i] ? ch
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-216-          --{{{  lock on to this channel for the whole message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-217-          SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-218-            WHILE ch <> end.message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-219-              SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-220-                --{{{  end.marker --> end.char
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-221-                IF
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ-222-                  ch = end.marker
kroc/modules/course/examples/sort_inside.occ-223-                    ch := end.char
--
kroc/modules/course/examples/bar.occ:327:          PRI ALT i = 0 FOR s
kroc/modules/course/examples/bar.occ-328-            INT any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-329-            in[i] ? any
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-330-              out ! any
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-331-      FAIRISH.ALT
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-332-        PRI ALT
kroc/modules/course/examples/bar.occ-333-          BOOL any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-334-          terminate ? any
kroc/modules/course/examples/bar.occ-335-            running := FALSE
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-336-          mode.change ? local.alt.mode
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-337-            SKIP
kroc/modules/course/examples/bar.occ:338:          PRI ALT j = favourite FOR s
kroc/modules/course/examples/bar.occ-339-            VAL INT X IS (j \ s):
kroc/modules/course/examples/bar.occ-340-            INT any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-341-            in[X] ? any
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-342-              SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-343-                out ! any
kroc/modules/course/examples/bar.occ-344-                favourite := ((favourite + 1) \ s)
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-345-      FAIR.ALT
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-346-        PRI ALT
kroc/modules/course/examples/bar.occ-347-          BOOL any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-348-          terminate ? any
--
kroc/modules/course/examples/bar.occ:352:          PRI ALT i = favourite FOR s
kroc/modules/course/examples/bar.occ-353-            VAL INT X IS (i \ s):
kroc/modules/course/examples/bar.occ-354-            INT any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-355-            in[X] ? any
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-356-              SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-357-                out ! any
kroc/modules/course/examples/bar.occ-358-                favourite := (X + 1)
kroc/modules/course/examples/bar.occ-359-:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-360---}}}
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-361-
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ-362---{{{  PROC bar.body (CHAN BYTE in?, []CHAN BYTE responses!, SHARED CHAN O.REQ out!, CHAN BOOL terminate?)
--
kroc/modules/course/examples/sort_pump.occ:184:      ALT i = 0 FOR n.inputs
kroc/modules/course/examples/sort_pump.occ-185-        BYTE ch:
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-186-        in[i] ? ch
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-187-          --{{{  lock on to this channel for the whole message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-188-          SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-189-            WHILE ch <> end.message
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-190-              SEQ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-191-                --{{{  end.marker --> end.char
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-192-                IF
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ-193-                  ch = end.marker
kroc/modules/course/examples/sort_pump.occ-194-                    ch := end.char
--
kroc/modules/course/exercises/q7.occ:118:    ALT i = 0 FOR n.philosophers
/home/david/projects/code-associates/occam2go/kroc/modules/course/exercises/q7.occ-119-      ALT
/home/david/projects/code-associates/occam2go/kroc/modules/course/exercises/q7.occ-120-        --{{{  philosopher wanting to sit down
kroc/modules/course/exercises/q7.occ-121-        BOOL any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/exercises/q7.occ-122-        (n.sat.down < max) & down[i] ? any    -- only allow up to max at a time
kroc/modules/course/exercises/q7.occ-123-          n.sat.down := n.sat.down + 1
/home/david/projects/code-associates/occam2go/kroc/modules/course/exercises/q7.occ-124-        --}}}
/home/david/projects/code-associates/occam2go/kroc/modules/course/exercises/q7.occ-125-        --{{{  philosopher wanting to stand up
kroc/modules/course/exercises/q7.occ-126-        BOOL any:
/home/david/projects/code-associates/occam2go/kroc/modules/course/exercises/q7.occ-127-        up[i] ? any                           -- always allow this
kroc/modules/course/exercises/q7.occ-128-          n.sat.down := n.sat.down - 1

77:	INT_TYPE
78:	BYTE_TYPE
79:	BOOL_TYPE
80:	REAL_TYPE
81:	REAL32_TYPE
82:	REAL64_TYPE
167:	INT_TYPE:  "INT",
168:	BYTE_TYPE: "BYTE",
169:	BOOL_TYPE: "BOOL",
170:	REAL_TYPE:   "REAL",
171:	REAL32_TYPE: "REAL32",
172:	REAL64_TYPE: "REAL64",
215:	"INT":   INT_TYPE,
216:	"BYTE":  BYTE_TYPE,
217:	"BOOL":  BOOL_TYPE,
218:	"REAL":   REAL_TYPE,
219:	"REAL32": REAL32_TYPE,
220:	"REAL64": REAL64_TYPE,

164:	case lexer.VAL:
165-		return p.parseAbbreviation()
166-	case lexer.INITIAL:
167-		return p.parseInitialDecl()
--
915:	case lexer.INT_TYPE:
916-		return "INT"
917:	case lexer.BYTE_TYPE:
918-		return "BYTE"
919:	case lexer.BOOL_TYPE:
920-		return "BOOL"
921:	case lexer.REAL_TYPE:
922-		return "REAL"
923-	case lexer.REAL32_TYPE:
924-		return "REAL32"

   130→	}
   131→	return LOWEST
   132→}
   133→
   134→func (p *Parser) curPrecedence() int {
   135→	if prec, ok := precedences[p.curToken.Type]; ok {
   136→		return prec
   137→	}
   138→	return LOWEST
   139→}
   140→
   141→// ParseProgram parses the entire program
   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→		if p.peekTokenIs(lexer.FUNCTION) || p.peekTokenIs(lexer.FUNC) || p.peekTokenIs(lexer.COMMA) || p.peekTokenIs(lexer.INLINE) {
   170→			return p.parseFuncDecl()
   171→		}
   172→		return p.parseVarDeclOrAbbreviation()
   173→	case lexer.LBRACKET:
   174→		return p.parseArrayDecl()
   175→	case lexer.CHAN:
   176→		return p.parseChanDecl()
   177→	case lexer.PROTOCOL:
   178→		return p.parseProtocolDecl()
   179→	case lexer.RECORD:
   180→		return p.parseRecordDecl()
   181→	case lexer.TIMER:
   182→		return p.parseTimerDecl()
   183→	case lexer.SEQ:
   184→		return p.parseSeqBlock()
   185→	case lexer.PAR:
   186→		return p.parseParBlock()
   187→	case lexer.ALT:
   188→		return p.parseAltBlock()
   189→	case lexer.SKIP:

Task #1 created successfully: Add Replicator and Declarations fields to AST

Task #2 created successfully: Add replicator parsing to parseAltBlock

Task #3 created successfully: Add reflect.Select codegen for replicated ALT

Task #4 created successfully: Add parser and e2e tests

Task #5 created successfully: Update documentation (TODO.md, CLAUDE.md)

Updated task #1 status

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

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

Updated task #1 status

Updated task #2 status

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

  1650→
  1651→func (p *Parser) parseAltCase() *ast.AltCase {
  1652→	altCase := &ast.AltCase{}
  1653→
  1654→	// Check for guard: expression & channel ? var
  1655→	// For now, we expect: channel ? var (no guard support yet)
  1656→	// or: guard & channel ? var
  1657→
  1658→	// First token should be identifier (channel name or guard start)
  1659→	if !p.curTokenIs(lexer.IDENT) && !p.curTokenIs(lexer.TRUE) && !p.curTokenIs(lexer.FALSE) {
  1660→		p.addError(fmt.Sprintf("expected channel name or guard in ALT case, got %s", p.curToken.Type))
  1661→		return nil
  1662→	}
  1663→
  1664→	// Look ahead to determine if this is a guard or channel
  1665→	// If next token is & then we have a guard
  1666→	// If next token is ? then it's a channel/timer receive
  1667→	if p.peekTokenIs(lexer.RECEIVE) {
  1668→		name := p.curToken.Literal
  1669→		if p.timerNames[name] {
  1670→			// Timer case: tim ? AFTER deadline
  1671→			altCase.IsTimer = true
  1672→			altCase.Timer = name
  1673→			p.nextToken() // move to ?
  1674→			if !p.expectPeek(lexer.AFTER) {
  1675→				return nil
  1676→			}
  1677→			p.nextToken() // move past AFTER
  1678→			altCase.Deadline = p.parseExpression(LOWEST)
  1679→		} else {
  1680→			// Simple case: channel ? var
  1681→			altCase.Channel = name
  1682→			p.nextToken() // move to ?
  1683→			if !p.expectPeek(lexer.IDENT) {
  1684→				return nil
  1685→			}
  1686→			altCase.Variable = p.curToken.Literal
  1687→		}
  1688→	} else if p.peekTokenIs(lexer.LBRACKET) {
  1689→		// Indexed channel case: cs[i] ? var
  1690→		name := p.curToken.Literal
  1691→		altCase.Channel = name
  1692→		p.nextToken() // move to [
  1693→		p.nextToken() // move past [
  1694→		altCase.ChannelIndex = p.parseExpression(LOWEST)
  1695→		if !p.expectPeek(lexer.RBRACKET) {
  1696→			return nil
  1697→		}
  1698→		if !p.expectPeek(lexer.RECEIVE) {
  1699→			return nil
  1700→		}
  1701→		if !p.expectPeek(lexer.IDENT) {
  1702→			return nil
  1703→		}
  1704→		altCase.Variable = p.curToken.Literal
  1705→	} else {
  1706→		// Could be a guard followed by & channel ? var
  1707→		// For simplicity, parse expression until we hit &
  1708→		// For now, only support simple TRUE/FALSE or identifier guards
  1709→		guard := p.parseExpression(LOWEST)
  1710→		altCase.Guard = guard
  1711→
  1712→		// Expect &
  1713→		if !p.peekTokenIs(lexer.AMPERSAND) {
  1714→			p.addError("expected & after guard in ALT case")
  1715→			return nil
  1716→		}
  1717→		p.nextToken() // move to &
  1718→		p.nextToken() // move past &
  1719→
  1720→		// Now expect channel ? var or channel[index] ? var
  1721→		if !p.curTokenIs(lexer.IDENT) {
  1722→			p.addError(fmt.Sprintf("expected channel name after guard, got %s", p.curToken.Type))
  1723→			return nil
  1724→		}
  1725→		altCase.Channel = p.curToken.Literal
  1726→
  1727→		if p.peekTokenIs(lexer.LBRACKET) {
  1728→			// Indexed channel with guard: guard & cs[i] ? var
  1729→			p.nextToken() // move to [
  1730→			p.nextToken() // move past [
  1731→			altCase.ChannelIndex = p.parseExpression(LOWEST)
  1732→			if !p.expectPeek(lexer.RBRACKET) {
  1733→				return nil
  1734→			}
  1735→		}
  1736→
  1737→		if !p.expectPeek(lexer.RECEIVE) {
  1738→			return nil
  1739→		}
  1740→		if !p.expectPeek(lexer.IDENT) {
  1741→			return nil
  1742→		}
  1743→		altCase.Variable = p.curToken.Literal
  1744→	}
  1745→
  1746→	// Skip to next line for the body
  1747→	for p.peekTokenIs(lexer.NEWLINE) {
  1748→		p.nextToken()
  1749→	}
  1750→
  1751→	// Expect INDENT for body
  1752→	if !p.peekTokenIs(lexer.INDENT) {
  1753→		p.addError("expected indented body after ALT case")
  1754→		return altCase
  1755→	}
  1756→	p.nextToken() // consume INDENT
  1757→	p.nextToken() // move into body
  1758→
  1759→	altCase.Body = p.parseBodyStatements()
  1760→
  1761→	return altCase
  1762→}
  1763→
  1764→func (p *Parser) parseBlockStatements() []ast.Statement {
  1765→	var statements []ast.Statement
  1766→	startLevel := p.indentLevel
  1767→
  1768→	p.nextToken() // move past INDENT
  1769→

263:func (p *Parser) parseVarDeclOrAbbreviation() ast.Statement {

   263→func (p *Parser) parseVarDeclOrAbbreviation() ast.Statement {
   264→	typeToken := p.curToken
   265→	typeName := p.curToken.Literal
   266→
   267→	// Consume the name
   268→	if !p.expectPeek(lexer.IDENT) {
   269→		return nil
   270→	}
   271→	name := p.curToken.Literal
   272→
   273→	// Check if this is an abbreviation (next token is IS)
   274→	if p.peekTokenIs(lexer.IS) {
   275→		p.nextToken() // consume IS
   276→		p.nextToken() // move to expression
   277→		value := p.parseExpression(LOWEST)
   278→
   279→		if !p.expectPeek(lexer.COLON) {
   280→			return nil
   281→		}
   282→
   283→		return &ast.Abbreviation{
   284→			Token: typeToken,
   285→			IsVal: false,
   286→			Type:  typeName,
   287→			Name:  name,
   288→			Value: value,
   289→		}
   290→	}
   291→
   292→	// Otherwise, it's a regular variable declaration — continue parsing names
   293→	decl := &ast.VarDecl{
   294→		Token: typeToken,
   295→		Type:  typeName,
   296→		Names: []string{name},
   297→	}
   298→
   299→	// Parse additional comma-separated names
   300→	for p.peekTokenIs(lexer.COMMA) {
   301→		p.nextToken() // consume comma
   302→		if !p.expectPeek(lexer.IDENT) {
   303→			return nil
   304→		}
   305→		decl.Names = append(decl.Names, p.curToken.Literal)
   306→	}
   307→
   308→	if !p.expectPeek(lexer.COLON) {
   309→		return nil
   310→	}
   311→
   312→	return decl
   313→}
   314→
   315→// parseAbbreviation parses VAL abbreviations:
   316→//   VAL INT x IS expr:          (typed VAL abbreviation)
   317→//   VAL []BYTE x IS "string":   (open array abbreviation)
   318→//   VAL x IS expr:              (untyped VAL abbreviation)
   319→//   VAL INT X RETYPES X :       (RETYPES declaration)
   320→//   VAL [n]INT X RETYPES X :    (array RETYPES declaration)
   321→// Current token is VAL.
   322→func (p *Parser) parseAbbreviation() ast.Statement {
   323→	token := p.curToken // VAL token
   324→
   325→	p.nextToken()
   326→
   327→	// Check for []TYPE (open array abbreviation)
   328→	isOpenArray := false
   329→	if p.curTokenIs(lexer.LBRACKET) && p.peekTokenIs(lexer.RBRACKET) {
   330→		isOpenArray = true
   331→		p.nextToken() // consume ]
   332→		p.nextToken() // move to type
   333→	}
   334→
   335→	// Check for [n]TYPE (fixed-size array, used in RETYPES)
   336→	isArray := false
   337→	var arraySize ast.Expression
   338→	if !isOpenArray && p.curTokenIs(lexer.LBRACKET) {
   339→		// Could be [n]TYPE name RETYPES ...
   340→		isArray = true
   341→		p.nextToken() // move past [
   342→		arraySize = p.parseExpression(LOWEST)
   343→		if !p.expectPeek(lexer.RBRACKET) {
   344→			return nil
   345→		}
   346→		p.nextToken() // move to type
   347→	}
   348→
   349→	// Check for untyped VAL abbreviation: VAL name IS expr :
   350→	// Detect: curToken is IDENT and peekToken is IS (no type keyword)
   351→	if !isOpenArray && !isArray && p.curTokenIs(lexer.IDENT) && p.peekTokenIs(lexer.IS) {
   352→		name := p.curToken.Literal
   353→		p.nextToken() // consume IS
   354→		p.nextToken() // move to expression
   355→		value := p.parseExpression(LOWEST)
   356→		if !p.expectPeek(lexer.COLON) {
   357→			return nil
   358→		}
   359→		return &ast.Abbreviation{
   360→			Token: token,
   361→			IsVal: true,
   362→			Type:  "",

1821:func (p *Parser) parseBodyStatements() []ast.Statement {

  1821→func (p *Parser) parseBodyStatements() []ast.Statement {
  1822→	var statements []ast.Statement
  1823→	startLevel := p.indentLevel
  1824→
  1825→	for !p.curTokenIs(lexer.EOF) {
  1826→		// Skip newlines
  1827→		for p.curTokenIs(lexer.NEWLINE) {
  1828→			p.nextToken()
  1829→		}
  1830→
  1831→		// Handle DEDENT tokens
  1832→		for p.curTokenIs(lexer.DEDENT) {
  1833→			if p.indentLevel < startLevel {
  1834→				return statements
  1835→			}
  1836→			p.nextToken()
  1837→		}
  1838→
  1839→		// Skip any more newlines after DEDENT
  1840→		for p.curTokenIs(lexer.NEWLINE) {
  1841→			p.nextToken()
  1842→		}
  1843→
  1844→		if p.curTokenIs(lexer.EOF) {
  1845→			break
  1846→		}
  1847→
  1848→		if p.indentLevel < startLevel {
  1849→			break
  1850→		}
  1851→
  1852→		// Safety guard: record position before parsing to detect no-progress
  1853→		prevToken := p.curToken
  1854→		prevPeek := p.peekToken
  1855→
  1856→		stmt := p.parseStatement()
  1857→		if stmt != nil {
  1858→			statements = append(statements, stmt)
  1859→		}
  1860→
  1861→		// Advance past the last token of the statement if needed
  1862→		if !p.curTokenIs(lexer.NEWLINE) && !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
  1863→			p.nextToken()
  1864→		}
  1865→
  1866→		// No-progress guard: if we haven't moved, break to prevent infinite loop
  1867→		if p.curToken == prevToken && p.peekToken == prevPeek {
  1868→			break
  1869→		}
  1870→	}

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

Updated task #2 status

Updated task #3 status

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

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

   124→			g.needMath = true
   125→		}
   126→		if g.containsIntrinsics(stmt) {
   127→			g.needMathBits = true
   128→		}
   129→		if g.containsRetypes(stmt) {
   130→			g.needMath = true
   131→		}
   132→		if proc, ok := stmt.(*ast.ProcDecl); ok {
   133→			g.procSigs[proc.Name] = proc.Params

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

   206→	g.writeLine("package main")
   207→	g.writeLine("")
   208→
   209→	// Write imports
   210→	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits || g.needBufio {
   211→		g.writeLine("import (")
   212→		g.indent++
   213→		if g.needBufio {
   214→			g.writeLine(`"bufio"`)
   215→		}
   216→		if g.needFmt {
   217→			g.writeLine(`"fmt"`)
   218→		}
   219→		if g.needMath {
   220→			g.writeLine(`"math"`)
   221→		}
   222→		if g.needMathBits {
   223→			g.writeLine(`"math/bits"`)
   224→		}
   225→		if g.needOs {
   226→			g.writeLine(`"os"`)
   227→		}
   228→		if g.needSync {
   229→			g.writeLine(`"sync"`)
   230→		}
   231→		if g.needTime {
   232→			g.writeLine(`"time"`)
   233→		}
   234→		g.indent--
   235→		g.writeLine(")")

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

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

2372:func (g *Generator) containsRetypes(stmt ast.Statement) bool {

  2372→func (g *Generator) containsRetypes(stmt ast.Statement) bool {
  2373→	switch s := stmt.(type) {
  2374→	case *ast.RetypesDecl:
  2375→		return true
  2376→	case *ast.SeqBlock:
  2377→		for _, inner := range s.Statements {
  2378→			if g.containsRetypes(inner) {
  2379→				return true
  2380→			}
  2381→		}
  2382→	case *ast.ParBlock:
  2383→		for _, inner := range s.Statements {
  2384→			if g.containsRetypes(inner) {
  2385→				return true
  2386→			}
  2387→		}
  2388→	case *ast.ProcDecl:
  2389→		for _, inner := range s.Body {
  2390→			if g.containsRetypes(inner) {
  2391→				return true
  2392→			}
  2393→		}
  2394→	case *ast.FuncDecl:
  2395→		for _, inner := range s.Body {
  2396→			if g.containsRetypes(inner) {
  2397→				return true
  2398→			}
  2399→		}
  2400→	case *ast.WhileLoop:
  2401→		for _, inner := range s.Body {
  2402→			if g.containsRetypes(inner) {
  2403→				return true
  2404→			}
  2405→		}
  2406→	case *ast.IfStatement:
  2407→		for _, choice := range s.Choices {
  2408→			if choice.NestedIf != nil && g.containsRetypes(choice.NestedIf) {
  2409→				return true
  2410→			}
  2411→			for _, inner := range choice.Body {
  2412→				if g.containsRetypes(inner) {
  2413→					return true
  2414→				}
  2415→			}
  2416→		}
  2417→	case *ast.CaseStatement:
  2418→		for _, choice := range s.Choices {
  2419→			for _, inner := range choice.Body {
  2420→				if g.containsRetypes(inner) {
  2421→					return true

  2420→				if g.containsRetypes(inner) {
  2421→					return true
  2422→				}
  2423→			}
  2424→		}
  2425→	}
  2426→	return false
  2427→}
  2428→
  2429→// walkStatements recursively walks a statement tree, applying fn to all expressions.
  2430→// Returns true if fn returns true for any expression.
  2431→func (g *Generator) walkStatements(stmt ast.Statement, fn func(ast.Expression) bool) bool {
  2432→	switch s := stmt.(type) {
  2433→	case *ast.Assignment:
  2434→		return g.walkExpr(s.Value, fn) || g.walkExpr(s.Index, fn)
  2435→	case *ast.MultiAssignment:
  2436→		for _, v := range s.Values {
  2437→			if g.walkExpr(v, fn) {
  2438→				return true
  2439→			}
  2440→		}
  2441→	case *ast.Abbreviation:
  2442→		return g.walkExpr(s.Value, fn)
  2443→	case *ast.SeqBlock:
  2444→		for _, inner := range s.Statements {
  2445→			if g.walkStatements(inner, fn) {
  2446→				return true
  2447→			}
  2448→		}
  2449→	case *ast.ParBlock:

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

  1610→}
  1611→
  1612→func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
  1613→	// ALT becomes Go select statement
  1614→	// For guards, we use a pattern with nil channels
  1615→
  1616→	// Check if any cases have guards
  1617→	hasGuards := false
  1618→	for _, c := range alt.Cases {
  1619→		if c.Guard != nil {
  1620→			hasGuards = true
  1621→			break
  1622→		}
  1623→	}
  1624→
  1625→	if hasGuards {
  1626→		// Generate channel variables for guarded cases
  1627→		for i, c := range alt.Cases {
  1628→			if c.Guard != nil {
  1629→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1630→				g.write(fmt.Sprintf("var _alt%d chan ", i))
  1631→				// We don't know the channel type here, so use interface{}
  1632→				// Actually, we should use the same type as the original channel
  1633→				// For now, let's just reference the original channel conditionally
  1634→				g.write(fmt.Sprintf("int = nil\n")) // Assuming int for now
  1635→				g.builder.WriteString(strings.Repeat("\t", g.indent))
  1636→				g.write(fmt.Sprintf("if "))
  1637→				g.generateExpression(c.Guard)
  1638→				g.write(fmt.Sprintf(" { _alt%d = %s }\n", i, goIdent(c.Channel)))
  1639→			}
  1640→		}
  1641→	}
  1642→
  1643→	g.writeLine("select {")
  1644→	for i, c := range alt.Cases {
  1645→		g.builder.WriteString(strings.Repeat("\t", g.indent))
  1646→		if c.IsTimer {
  1647→			g.write("case <-time.After(time.Duration(")
  1648→			g.generateExpression(c.Deadline)
  1649→			g.write(" - int(time.Now().UnixMicro())) * time.Microsecond):\n")
  1650→		} else if c.Guard != nil {
  1651→			g.write(fmt.Sprintf("case %s = <-_alt%d:\n", goIdent(c.Variable), i))
  1652→		} else if c.ChannelIndex != nil {
  1653→			g.write(fmt.Sprintf("case %s = <-%s[", goIdent(c.Variable), goIdent(c.Channel)))
  1654→			g.generateExpression(c.ChannelIndex)
  1655→			g.write("]:\n")
  1656→		} else {
  1657→			g.write(fmt.Sprintf("case %s = <-%s:\n", goIdent(c.Variable), goIdent(c.Channel)))
  1658→		}
  1659→		g.indent++
  1660→		for _, s := range c.Body {
  1661→			g.generateStatement(s)
  1662→		}
  1663→		g.indent--
  1664→	}
  1665→	g.writeLine("}")
  1666→}
  1667→
  1668→func (g *Generator) generateProcDecl(proc *ast.ProcDecl) {
  1669→	// Track reference parameters for this procedure

1025:func (g *Generator) generateVarDecl(decl *ast.VarDecl) {

  1025→func (g *Generator) generateVarDecl(decl *ast.VarDecl) {
  1026→	goType := g.occamTypeToGo(decl.Type)
  1027→	goNames := make([]string, len(decl.Names))
  1028→	for i, n := range decl.Names {
  1029→		goNames[i] = goIdent(n)
  1030→	}
  1031→	g.writeLine(fmt.Sprintf("var %s %s", strings.Join(goNames, ", "), goType))
  1032→	// Suppress "declared and not used" for each variable
  1033→	for _, n := range goNames {
  1034→		g.writeLine(fmt.Sprintf("_ = %s", n))
  1035→	}
  1036→}
  1037→
  1038→func (g *Generator) generateAbbreviation(abbr *ast.Abbreviation) {
  1039→	g.builder.WriteString(strings.Repeat("\t", g.indent))
  1040→	g.write(fmt.Sprintf("%s := ", goIdent(abbr.Name)))
  1041→	g.generateExpression(abbr.Value)
  1042→	g.write("\n")
  1043→	// Suppress "declared and not used" for abbreviations inside function bodies
  1044→	if g.nestingLevel > 0 {
  1045→		g.writeLine(fmt.Sprintf("_ = %s", goIdent(abbr.Name)))
  1046→	}
  1047→}
  1048→
  1049→func (g *Generator) generateChanDecl(decl *ast.ChanDecl) {
  1050→	goType := g.occamTypeToGo(decl.ElemType)
  1051→	if decl.IsArray {
  1052→		for _, name := range decl.Names {
  1053→			n := goIdent(name)
  1054→			g.builder.WriteString(strings.Repeat("\t", g.indent))

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

?   	github.com/codeassociates/occam2go	[no test files]
?   	github.com/codeassociates/occam2go/ast	[no test files]
ok  	github.com/codeassociates/occam2go/codegen	16.145s
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)

Updated task #3 status

Updated task #4 status

274:func TestAltBlock(t *testing.T) {
316:func TestAltBlockWithGuard(t *testing.T) {

   274→func TestAltBlock(t *testing.T) {
   275→	input := `ALT
   276→  c1 ? x
   277→    SKIP
   278→  c2 ? y
   279→    SKIP
   280→`
   281→	l := lexer.New(input)
   282→	p := New(l)
   283→	program := p.ParseProgram()
   284→	checkParserErrors(t, p)
   285→
   286→	if len(program.Statements) != 1 {
   287→		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
   288→	}
   289→
   290→	alt, ok := program.Statements[0].(*ast.AltBlock)
   291→	if !ok {
   292→		t.Fatalf("expected AltBlock, got %T", program.Statements[0])
   293→	}
   294→
   295→	if len(alt.Cases) != 2 {
   296→		t.Fatalf("expected 2 cases, got %d", len(alt.Cases))
   297→	}
   298→
   299→	if alt.Cases[0].Channel != "c1" {
   300→		t.Errorf("expected channel 'c1', got %s", alt.Cases[0].Channel)
   301→	}
   302→
   303→	if alt.Cases[0].Variable != "x" {
   304→		t.Errorf("expected variable 'x', got %s", alt.Cases[0].Variable)
   305→	}
   306→
   307→	if alt.Cases[1].Channel != "c2" {
   308→		t.Errorf("expected channel 'c2', got %s", alt.Cases[1].Channel)
   309→	}
   310→
   311→	if alt.Cases[1].Variable != "y" {
   312→		t.Errorf("expected variable 'y', got %s", alt.Cases[1].Variable)
   313→	}
   314→}
   315→
   316→func TestAltBlockWithGuard(t *testing.T) {
   317→	input := `ALT
   318→  TRUE & c1 ? x
   319→    SKIP
   320→  FALSE & c2 ? y
   321→    SKIP
   322→`
   323→	l := lexer.New(input)
   324→	p := New(l)
   325→	program := p.ParseProgram()
   326→	checkParserErrors(t, p)
   327→
   328→	if len(program.Statements) != 1 {
   329→		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
   330→	}
   331→
   332→	alt, ok := program.Statements[0].(*ast.AltBlock)
   333→	if !ok {

3190 /home/david/projects/code-associates/occam2go/parser/parser_test.go

  3180→	}
  3181→
  3182→	// First choice condition should be a BinaryExpr (TRUE AND TRUE)
  3183→	binExpr, ok := ifStmt.Choices[0].Condition.(*ast.BinaryExpr)
  3184→	if !ok {
  3185→		t.Fatalf("expected BinaryExpr for first choice condition, got %T", ifStmt.Choices[0].Condition)
  3186→	}
  3187→	if binExpr.Operator != "AND" {
  3188→		t.Errorf("expected operator 'AND', got %q", binExpr.Operator)
  3189→	}
  3190→}
  3191→

codegen/e2e_helpers_test.go:16:func transpileCompileRun(t *testing.T, occamSource string) string {
codegen/e2e_helpers_test.go:67:func transpileCompileRunFromFile(t *testing.T, mainFile string, includePaths []string) string {
codegen/e2e_course_test.go:16:func transpileCompileRunWithDefines(t *testing.T, mainFile string, includePaths []string, defines map[string]string) string {

266 /home/david/projects/code-associates/occam2go/codegen/e2e_concurrency_test.go

   255→  INT result:
   256→  PAR
   257→    c ! 42
   258→    c ? result
   259→  print.int(result)
   260→`
   261→	output := transpileCompileRun(t, occam)
   262→	expected := "42\n"
   263→	if output != expected {
   264→		t.Errorf("expected %q, got %q", expected, output)
   265→	}
   266→}
   267→

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

=== RUN   TestAltReplicator
--- PASS: TestAltReplicator (0.00s)
=== RUN   TestAltReplicatorWithAbbreviation
--- PASS: TestAltReplicatorWithAbbreviation (0.00s)
PASS
ok  	github.com/codeassociates/occam2go/parser	0.001s

   240→  CHAN OF INT c:
   241→  PAR
   242→    producer(c)
   243→    consumer(c)
   244→`
   245→	output := transpileCompileRun(t, occam)
   246→	expected := "42\n"
   247→	if output != expected {
   248→		t.Errorf("expected %q, got %q", expected, output)
   249→	}
   250→}
   251→
   252→func TestE2EChanShorthand(t *testing.T) {
   253→	occam := `SEQ
   254→  CHAN INT c:
   255→  INT result:
   256→  PAR
   257→    c ! 42
   258→    c ? result
   259→  print.int(result)
   260→`
   261→	output := transpileCompileRun(t, occam)
   262→	expected := "42\n"
   263→	if output != expected {
   264→		t.Errorf("expected %q, got %q", expected, output)
   265→	}
   266→}
   267→

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

  1670→	g.writeLine("}")
  1671→}
  1672→
  1673→func (g *Generator) generateReplicatedAlt(alt *ast.AltBlock) {
  1674→	// Replicated ALT: ALT i = start FOR count
  1675→	// Uses reflect.Select for runtime-variable case count
  1676→	if len(alt.Cases) == 0 {
  1677→		return
  1678→	}
  1679→	c := alt.Cases[0]
  1680→	rep := alt.Replicator
  1681→	v := goIdent(rep.Variable)
  1682→
  1683→	// Determine receive type from scoped declarations
  1684→	recvType := "int" // default
  1685→	for _, decl := range c.Declarations {
  1686→		if vd, ok := decl.(*ast.VarDecl); ok {
  1687→			for _, name := range vd.Names {
  1688→				if name == c.Variable {
  1689→					recvType = g.occamTypeToGo(vd.Type)
  1690→					break
  1691→				}
  1692→			}
  1693→		}
  1694→	}
  1695→
  1696→	// Open a block for scoping
  1697→	g.writeLine("{")
  1698→	g.indent++
  1699→
  1700→	// _altCount := int(<count>)
  1701→	g.builder.WriteString(strings.Repeat("\t", g.indent))
  1702→	g.write("_altCount := int(")
  1703→	g.generateExpression(rep.Count)
  1704→	g.write(")\n")
  1705→
  1706→	// _altCases := make([]reflect.SelectCase, _altCount)
  1707→	g.writeLine("_altCases := make([]reflect.SelectCase, _altCount)")
  1708→
  1709→	// Setup loop: build select cases

  1735→	g.builder.WriteString(strings.Repeat("\t", g.indent))
  1736→	g.write("_altCases[_altI] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(")
  1737→	if c.ChannelIndex != nil {
  1738→		g.write(goIdent(c.Channel) + "[")
  1739→		g.generateExpression(c.ChannelIndex)
  1740→		g.write("]")
  1741→	} else {
  1742→		g.write(goIdent(c.Channel))
  1743→	}
  1744→	g.write(")}\n")
  1745→
  1746→	g.indent--
  1747→	g.writeLine("}")
  1748→
  1749→	// Call reflect.Select
  1750→	g.writeLine("_altChosen, _altValue, _ := reflect.Select(_altCases)")
  1751→
  1752→	// Recompute replicator variable from chosen index
  1753→	g.builder.WriteString(strings.Repeat("\t", g.indent))
  1754→	if rep.Step != nil {
  1755→		g.write(fmt.Sprintf("%s := ", v))
  1756→		g.generateExpression(rep.Start)
  1757→		g.write(" + _altChosen * (")
  1758→		g.generateExpression(rep.Step)
  1759→		g.write(")\n")
  1760→	} else {
  1761→		g.write(fmt.Sprintf("%s := ", v))
  1762→		g.generateExpression(rep.Start)
  1763→		g.write(" + _altChosen\n")
  1764→	}
  1765→
  1766→	// Generate scoped var declarations
  1767→	for _, decl := range c.Declarations {
  1768→		if vd, ok := decl.(*ast.VarDecl); ok {
  1769→			g.generateVarDecl(vd)
  1770→		}
  1771→	}
  1772→
  1773→	// Generate scoped abbreviations
  1774→	for _, decl := range c.Declarations {

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

=== RUN   TestE2E_ReplicatedAltBasic
--- PASS: TestE2E_ReplicatedAltBasic (0.09s)
=== RUN   TestE2E_ReplicatedAltIndex
--- PASS: TestE2E_ReplicatedAltIndex (0.09s)
=== RUN   TestE2E_ReplicatedAltWithAbbreviation
--- PASS: TestE2E_ReplicatedAltWithAbbreviation (0.09s)
=== RUN   TestE2E_ReplicatedAltByte
--- PASS: TestE2E_ReplicatedAltByte (0.09s)
PASS
ok  	github.com/codeassociates/occam2go/codegen	0.355s

?   	github.com/codeassociates/occam2go	[no test files]
?   	github.com/codeassociates/occam2go/ast	[no test files]
ok  	github.com/codeassociates/occam2go/codegen	16.667s
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)

	first_col := 1
	_ = first_col
	var xx, yy byte
	_ = xx
	_ = yy
	xx = first_col
	yy = first_line
	for true {
		var ch byte
		_ = ch
		ch = <-in
		if (ch != end_marker) {
			cursor_x_y(xx, yy, out)
			out <- ch
			out <- end_message
			xx = (xx + 1)
		} else if (xx > first_col) {
			xx = first_col
			if (yy < last_line) {
				yy = (yy + 1)
			} else if true {

9:	"reflect"
2778:			_altCases := make([]reflect.SelectCase, _altCount)
2781:				_altCases[_altI] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(in[i])}
2783:			_altChosen, _altValue, _ := reflect.Select(_altCases)

func screen_plex(n_inputs int, in []<-chan byte, out chan<- byte) {
	cursor_x_y(1, 1, out)
	erase_eos(out)
	flush(out)
	for true {
		{
			_altCount := int(n_inputs)
			_altCases := make([]reflect.SelectCase, _altCount)
			for _altI := 0; _altI < _altCount; _altI++ {
				i := 0 + _altI
				_altCases[_altI] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(in[i])}
			}
			_altChosen, _altValue, _ := reflect.Select(_altCases)
			i := 0 + _altChosen
			_ = i
			var ch byte
			_ = ch
			ch = _altValue.Interface().(byte)
			for (ch != end_message) {
				if (ch == end_marker) {
					ch = end_char
				} else if true {
					// SKIP
				}
				out <- ch
				ch = <-in[i]
			}
			flush(out)
		}
	}

Exit code: 0

Updated task #4 status

Updated task #5 status

11:- **ALT** — Channel alternation, maps to Go `select`; supports boolean guards, timer timeouts, and multi-statement bodies
89:| **`DATA TYPE X RECORD`** | Alternative record syntax (vs current `RECORD X`). | shared_screen.inc |
97:| **PRI ALT / PRI PAR** | Priority variants of ALT and PAR. |

     8→- **IF** — Multi-branch conditionals, maps to if/else if chains, with replicators; supports multi-statement bodies (declarations scoped before process)
     9→- **WHILE** — Loops, maps to Go `for` loops; supports multi-statement bodies
    10→- **CASE** — Pattern matching with multiple cases and ELSE branch; supports multi-statement bodies
    11→- **ALT** — Channel alternation, maps to Go `select`; supports boolean guards, timer timeouts, and multi-statement bodies
    12→- **SKIP** — No-op process
    13→- **STOP** — Error + deadlock
    14→
    15→### Data Types & Declarations
    16→- **INT, BYTE, BOOL, REAL, REAL32, REAL64** — Scalar types (REAL/REAL64 map to float64, REAL32 maps to float32)
    17→- **Variable declarations** — `INT x, y, z:`

The file /home/david/projects/code-associates/occam2go/TODO.md has been updated successfully.

    85→
    86→| Feature | Notes | Used in |
    87→|---------|-------|---------|
    88→| **`DATA TYPE X IS TYPE:`** | Simple type alias (e.g. `DATA TYPE COLOUR IS BYTE:`). | shared_screen.inc |
    89→| **`DATA TYPE X RECORD`** | Alternative record syntax (vs current `RECORD X`). | shared_screen.inc |
    90→| **Counted array protocol** | `BYTE::[]BYTE` — length-prefixed array in protocols. | shared_screen.inc, shared_screen.occ |
    91→| **`RESULT` param qualifier** | `RESULT INT len` on PROC params (output-only, like a write-only reference). | float_io.occ |
    92→
    93→### Other language features
    94→
    95→| Feature | Notes |
    96→|---------|-------|
    97→| **PRI ALT / PRI PAR** | Priority variants of ALT and PAR. |
    98→| **PLACED PAR** | Assigning processes to specific hardware. |
    99→| **PORT OF** | Hardware port mapping. |
   100→| **`VAL []BYTE` abbreviations** | `VAL []BYTE cmap IS "0123456789ABCDEF":` — named string constants. |
   101→| **`#PRAGMA DEFINED`** | Compiler hint to suppress definedness warnings. Can be ignored. |
   102→

72:| `ALT` | `select` |
174:[Omitted long matching line]

    70→| `CASE x` | `switch x` |
    71→| `STOP` | `fmt.Fprintln(os.Stderr, ...)` + `select {}` |
    72→| `ALT` | `select` |
    73→| `CHAN OF INT c:` | `c := make(chan int)` |
    74→| `c ! expr` | `c <- expr` |

The file /home/david/projects/code-associates/occam2go/CLAUDE.md has been updated successfully.

   170→5. **Tests**: Add parser unit tests in `parser/parser_test.go`, codegen unit tests in `codegen/codegen_test.go`, and e2e tests in `codegen/e2e_test.go`
   171→6. **Documentation**: Update TODO.md to reflect support for the new feature.
   172→
   173→## What's Implemented
   174→
   175→Preprocessor (`#IF`/`#ELSE`/`#ENDIF`/`#DEFINE`/`#INCLUDE` with search paths, include guards, include-once deduplication, `#COMMENT`/`#PRAGMA`/`#USE` ignored), module file generation from SConscript (`gen-module` subcommand), SEQ, PAR, IF, WHILE, CASE, ALT (with guards, timer timeouts, and multi-statement bodies with scoped declarations), SKIP, STOP, variable/array/channel/timer declarations, abbreviations (`VAL INT x IS 42:`, `INT y IS z:`, `VAL []BYTE s IS "hi":`, untyped `VAL x IS expr:`), assignments (simple and indexed), channel send/receive, channel arrays (`[n]CHAN OF TYPE` with indexed send/receive and `[]CHAN OF TYPE` proc params), PROC (with VAL, RESULT, reference, CHAN, []CHAN, open array `[]TYPE`, fixed-size array `[n]TYPE`, and shared-type params), channel direction restrictions (`CHAN OF INT c?` → `<-chan int`, `CHAN OF INT c!` → `chan<- int`, call-site annotations `out!`/`in?` accepted), multi-line parameter lists and expressions (lexer suppresses INDENT/DEDENT/NEWLINE inside parens/brackets and after continuation operators), FUNCTION (IS and VALOF forms with multi-statement bodies, including multi-result `INT, INT FUNCTION` with `RESULT a, b`), multi-assignment (`a, b := func(...)` including indexed targets like `x[0], x[1] := x[1], x[0]`), KRoC-style colon terminators on PROC/FUNCTION (optional), INLINE function modifier (accepted and ignored), replicators on SEQ/PAR/IF (with optional STEP), arithmetic/comparison/logical/AFTER/bitwise operators, type conversions (`INT expr`, `BYTE expr`, `REAL32 expr`, `REAL64 expr`, etc.), REAL32/REAL64 types, hex integer literals (`#FF`, `#80000000`), string literals, byte literals (`'A'`, `'*n'` with occam escape sequences), built-in print procedures, protocols (simple, sequential, and variant), record types (with field access via bracket syntax), SIZE operator, array slices (`[arr FROM n FOR m]` and shorthand `[arr FOR m]` with slice assignment), array literals (`[1, 2, 3]`), nested PROCs/FUNCTIONs (local definitions as Go closures), MOSTNEG/MOSTPOS (type min/max constants for INT, BYTE, REAL32, REAL64), INITIAL declarations (`INITIAL INT x IS 42:` — mutable variable with initial value), checked (modular) arithmetic (`PLUS`, `MINUS`, `TIMES` — wrapping operators), RETYPES (bit-level type reinterpretation: `VAL INT X RETYPES X :` for float32→int, `VAL [2]INT X RETYPES X :` for float64→int pair), transputer intrinsics (LONGPROD, LONGDIV, LONGSUM, LONGDIFF, NORMALISE, SHIFTRIGHT, SHIFTLEFT — implemented as Go helper functions), CAUSEERROR (maps to `panic("CAUSEERROR")`).
   176→
   177→## Course Module Testing
   178→
   179→The KRoC course module (`kroc/modules/course/libsrc/course.module`) is a real-world integration test:

The file /home/david/projects/code-associates/occam2go/CLAUDE.md has been updated successfully.

The file /home/david/projects/code-associates/occam2go/CLAUDE.md has been updated successfully.

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	(cached)
ok  	github.com/codeassociates/occam2go/lexer	(cached)
ok  	github.com/codeassociates/occam2go/modgen	(cached)
ok  	github.com/codeassociates/occam2go/parser	(cached)
ok  	github.com/codeassociates/occam2go/preproc	(cached)

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:   CLAUDE.md
	modified:   TODO.md
	modified:   ast/ast.go
	modified:   codegen/codegen.go
	modified:   codegen/e2e_concurrency_test.go
	modified:   parser/parser.go
	modified:   parser/parser_test.go

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

3cbf1cd Merge pull request #47 from codeassociates/feat/inline-function-modifier
14c62e1 Support INLINE function modifier
a6f7350 Merge pull request #42 from codeassociates/feat/source-map-error-messages
9227d08 Add source file tracking to parser error messages
d6b665f Merge pull request #38 from codeassociates/docs/gen-module-limitation

diff --git a/CLAUDE.md b/CLAUDE.md
index 7e50fdd..4c7b3ac 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -70,6 +70,7 @@ Six packages, one pipeline:
 | `CASE x` | `switch x` |
 | `STOP` | `fmt.Fprintln(os.Stderr, ...)` + `select {}` |
 | `ALT` | `select` |
+| `ALT i = 0 FOR n` | `reflect.Select` with runtime case slice |
 | `CHAN OF INT c:` | `c := make(chan int)` |
 | `c ! expr` | `c <- expr` |
 | `c ? x` | `x = <-c` |
@@ -171,7 +172,7 @@ Typical workflow for a new language construct:
 
 ## What's Implemented
 
-Preprocessor (`#IF`/`#ELSE`/`#ENDIF`/`#DEFINE`/`#INCLUDE` with search paths, include guards, include-once deduplication, `#COMMENT`/`#PRAGMA`/`#USE` ignored), module file generation from SConscript (`gen-module` subcommand), SEQ, PAR, IF, WHILE, CASE, ALT (with guards, timer timeouts, and multi-statement bodies with scoped declarations), SKIP, STOP, variable/array/channel/timer declarations, abbreviations (`VAL INT x IS 42:`, `INT y IS z:`, `VAL []BYTE s IS "hi":`, untyped `VAL x IS expr:`), assignments (simple and indexed), channel send/receive, channel arrays (`[n]CHAN OF TYPE` with indexed send/receive and `[]CHAN OF TYPE` proc params), PROC (with VAL, RESULT, reference, CHAN, []CHAN, open array `[]TYPE`, fixed-size array `[n]TYPE`, and shared-type params), channel direction restrictions (`CHAN OF INT c?` → `<-chan int`, `CHAN OF INT c!` → `chan<- int`, call-site annotations `out!`/`in?` accepted), multi-line parameter lists and expressions (lexer suppresses INDENT/DEDENT/NEWLINE inside parens/brackets and after continuation operators), FUNCTION (IS and VALOF forms with multi-statement bodies, including multi-result `INT, INT FUNCTION` with `RESULT a, b`), multi-assignment (`a, b := func(...)` including indexed targets like `x[0], x[1] := x[1], x[0]`), KRoC-style colon terminators on PROC/FUNCTION (optional), INLINE function modifier (accepted and ignored), replicators on SEQ/PAR/IF (with optional STEP), arithmetic/comparison/logical/AFTER/bitwise operators, type conversions (`INT expr`, `BYTE expr`, `REAL32 expr`, `REAL64 expr`, etc.), REAL32/REAL64 types, hex integer literals (`#FF`, `#80000000`), string literals, byte literals (`'A'`, `'*n'` with occam escape sequences), built-in print procedures, protocols (simple, sequential, and variant), record types (with field access via bracket syntax), SIZE operator, array slices (`[arr FROM n FOR m]` and shorthand `[arr FOR m]` with slice assignment), array literals (`[1, 2, 3]`), nested PROCs/FUNCTIONs (local definitions as Go closures), MOSTNEG/MOSTPOS (type min/max constants for INT, BYTE, REAL32, REAL64), INITIAL declarations (`INITIAL INT x IS 42:` — mutable variable with initial value), checked (modular) arithmetic (`PLUS`, `MINUS`, `TIMES` — wrapping operators), RETYPES (bit-level type reinterpretation: `VAL INT X RETYPES X :` for float32→int, `VAL [2]INT X RETYPES X :` for float64→int pair), transputer intrinsics (LONGPROD, LONGDIV, LONGSUM, LONGDIFF, NORMALISE, SHIFTRIGHT, SHIFTLEFT — implemented as Go helper functions), CAUSEERROR (maps to `panic("CAUSEERROR")`).
+Preprocessor (`#IF`/`#ELSE`/`#ENDIF`/`#DEFINE`/`#INCLUDE` with search paths, include guards, include-once deduplication, `#COMMENT`/`#PRAGMA`/`#USE` ignored), module file generation from SConscript (`gen-module` subcommand), SEQ, PAR, IF, WHILE, CASE, ALT (with guards, timer timeouts, multi-statement bodies with scoped declarations, and replicators using `reflect.Select`), SKIP, STOP, variable/array/channel/timer declarations, abbreviations (`VAL INT x IS 42:`, `INT y IS z:`, `VAL []BYTE s IS "hi":`, untyped `VAL x IS expr:`), assignments (simple and indexed), channel send/receive, channel arrays (`[n]CHAN OF TYPE` with indexed send/receive and `[]CHAN OF TYPE` proc params), PROC (with VAL, RESULT, reference, CHAN, []CHAN, open array `[]TYPE`, fixed-size array `[n]TYPE`, and shared-type params), channel direction restrictions (`CHAN OF INT c?` → `<-chan int`, `CHAN OF INT c!` → `chan<- int`, call-site annotations `out!`/`in?` accepted), multi-line parameter lists and expressions (lexer suppresses INDENT/DEDENT/NEWLINE inside parens/brackets and after continuation operators), FUNCTION (IS and VALOF forms with multi-statement bodies, including multi-result `INT, INT FUNCTION` with `RESULT a, b`), multi-assignment (`a, b := func(...)` including indexed targets like `x[0], x[1] := x[1], x[0]`), KRoC-style colon terminators on PROC/FUNCTION (optional), INLINE function modifier (accepted and ignored), replicators on SEQ/PAR/IF/ALT (with optional STEP), arithmetic/comparison/logical/AFTER/bitwise operators, type conversions (`INT expr`, `BYTE expr`, `REAL32 expr`, `REAL64 expr`, etc.), REAL32/REAL64 types, hex integer literals (`#FF`, `#80000000`), string literals, byte literals (`'A'`, `'*n'` with occam escape sequences), built-in print procedures, protocols (simple, sequential, and variant), record types (with field access via bracket syntax), SIZE operator, array slices (`[arr FROM n FOR m]` and shorthand `[arr FOR m]` with slice assignment), array literals (`[1, 2, 3]`), nested PROCs/FUNCTIONs (local definitions as Go closures), MOSTNEG/MOSTPOS (type min/max constants for INT, BYTE, REAL32, REAL64), INITIAL declarations (`INITIAL INT x IS 42:` — mutable variable with initial value), checked (modular) arithmetic (`PLUS`, `MINUS`, `TIMES` — wrapping operators), RETYPES (bit-level type reinterpretation: `VAL INT X RETYPES X :` for float32→int, `VAL [2]INT X RETYPES X :` for float64→int pair), transputer intrinsics (LONGPROD, LONGDIV, LONGSUM, LONGDIFF, NORMALISE, SHIFTRIGHT, SHIFTLEFT — implemented as Go helper functions), CAUSEERROR (maps to `panic("CAUSEERROR")`).
 
 ## Course Module Testing
 
diff --git a/TODO.md b/TODO.md
index 79ee539..fb1344f 100644
--- a/TODO.md
+++ b/TODO.md
@@ -8,7 +8,7 @@
 - **IF** — Multi-branch conditionals, maps to if/else if chains, with replicators; supports multi-statement bodies (declarations scoped before process)
 - **WHILE** — Loops, maps to Go `for` loops; supports multi-statement bodies
 - **CASE** — Pattern matching with multiple cases and ELSE branch; supports multi-statement bodies
-- **ALT** — Channel alternation, maps to Go `select`; supports boolean guards, timer timeouts, and multi-statement bodies
+- **ALT** — Channel alternation, maps to Go `select`; supports boolean guards, timer timeouts, multi-statement bodies, and replicators (`ALT i = 0 FOR n` using `reflect.Select`)
 - **SKIP** — No-op process
 - **STOP** — Error + deadlock
 
diff --git a/ast/ast.go b/ast/ast.go
index 894ad1c..c8db3a7 100644
--- a/ast/ast.go
+++ b/ast/ast.go
@@ -382,9 +382,11 @@ func (r *Receive) statementNode()       {}
 func (r *Receive) TokenLiteral() string { return r.Token.Literal }
 
 // AltBlock represents an ALT block (alternation/select)
+// If Replicator is non-nil, this is a replicated ALT (ALT i = 0 FOR n)
 type AltBlock struct {
-	Token lexer.Token // the ALT token
-	Cases []AltCase
+	Token      lexer.Token // the ALT token
+	Cases      []AltCase
+	Replicator *Replicator // optional replicator
 }
 
 func (a *AltBlock) statementNode()       {}
@@ -400,6 +402,7 @@ type AltCase struct {
 	IsTimer      bool        // true if this is a timer AFTER case
 	Timer        string      // timer name (when IsTimer)
 	Deadline     Expression  // AFTER deadline expression (when IsTimer)
+	Declarations []Statement // scoped declarations before channel input (e.g., BYTE ch:)
 }
 
 // TimerDecl represents a timer declaration: TIMER tim:
diff --git a/codegen/codegen.go b/codegen/codegen.go
index d9b2d69..b246df4 100644
--- a/codegen/codegen.go
+++ b/codegen/codegen.go
@@ -18,6 +18,7 @@ type Generator struct {
 	needMath bool // track if we need math package import
 	needMathBits bool // track if we need math/bits package import
 	needBufio    bool // track if we need bufio package import
+	needReflect  bool // track if we need reflect package import
 
 	// Track procedure signatures for proper pointer handling
 	procSigs map[string][]ast.ProcParam
@@ -95,6 +96,7 @@ func (g *Generator) Generate(program *ast.Program) string {
 	g.needMath = false
 	g.needMathBits = false
 	g.needBufio = false
+	g.needReflect = false
 	g.procSigs = make(map[string][]ast.ProcParam)
 	g.refParams = make(map[string]bool)
 	g.protocolDefs = make(map[string]*ast.ProtocolDecl)
@@ -127,6 +129,9 @@ func (g *Generator) Generate(program *ast.Program) string {
 		if g.containsRetypes(stmt) {
 			g.needMath = true
 		}
+		if g.containsAltReplicator(stmt) {
+			g.needReflect = true
+		}
 		if proc, ok := stmt.(*ast.ProcDecl); ok {
 			g.procSigs[proc.Name] = proc.Params
 			g.collectNestedProcSigs(proc.Body)
@@ -202,7 +207,7 @@ func (g *Generator) Generate(program *ast.Program) string {
 	g.writeLine("")
 
 	// Write imports
-	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits || g.needBufio {
+	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits || g.needBufio || g.needReflect {
 		g.writeLine("import (")
 		g.indent++
 		if g.needBufio {
@@ -220,6 +225,9 @@ func (g *Generator) Generate(program *ast.Program) string {
 		if g.needOs {
 			g.writeLine(`"os"`)
 		}
+		if g.needReflect {
+			g.writeLine(`"reflect"`)
+		}
 		if g.needSync {
 			g.writeLine(`"sync"`)
 		}
@@ -1602,6 +1610,11 @@ func (g *Generator) generateParBlock(par *ast.ParBlock) {
 }
 
 func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
+	if alt.Replicator != nil {
+		g.generateReplicatedAlt(alt)
+		return
+	}
+
 	// ALT becomes Go select statement
 	// For guards, we use a pattern with nil channels
 
@@ -1657,6 +1670,126 @@ func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
 	g.writeLine("}")
 }
 
+func (g *Generator) generateReplicatedAlt(alt *ast.AltBlock) {
+	// Replicated ALT: ALT i = start FOR count
+	// Uses reflect.Select for runtime-variable case count
+	if len(alt.Cases) == 0 {
+		return
+	}
+	c := alt.Cases[0]
+	rep := alt.Replicator
+	v := goIdent(rep.Variable)
+
+	// Determine receive type from scoped declarations
+	recvType := "int" // default
+	for _, decl := range c.Declarations {
+		if vd, ok := decl.(*ast.VarDecl); ok {
+			for _, name := range vd.Names {
+				if name == c.Variable {
+					recvType = g.occamTypeToGo(vd.Type)
+					break
+				}
+			}
+		}
+	}
+
+	// Open a block for scoping
+	g.writeLine("{")
+	g.indent++
+
+	// _altCount := int(<count>)
+	g.builder.WriteString(strings.Repeat("\t", g.indent))
+	g.write("_altCount := int(")
+	g.generateExpression(rep.Count)
+	g.write(")\n")
+
+	// _altCases := make([]reflect.SelectCase, _altCount)
+	g.writeLine("_altCases := make([]reflect.SelectCase, _altCount)")
+
+	// Setup loop: build select cases
+	g.writeLine("for _altI := 0; _altI < _altCount; _altI++ {")
+	g.indent++
+
+	// Compute replicator variable
+	g.builder.WriteString(strings.Repeat("\t", g.indent))
+	if rep.Step != nil {
+		g.write(fmt.Sprintf("%s := ", v))
+		g.generateExpression(rep.Start)
+		g.write(" + _altI * (")
+		g.generateExpression(rep.Step)
+		g.write(")\n")
+	} else {
+		g.write(fmt.Sprintf("%s := ", v))
+		g.generateExpression(rep.Start)
+		g.write(" + _altI\n")
+	}
+
+	// Generate scoped abbreviations (needed for channel index computation)
+	for _, decl := range c.Declarations {
+		if abbr, ok := decl.(*ast.Abbreviation); ok {
+			g.generateAbbreviation(abbr)
+		}
+	}
+
+	// Build select case entry
+	g.builder.WriteString(strings.Repeat("\t", g.indent))
+	g.write("_altCases[_altI] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(")
+	if c.ChannelIndex != nil {
+		g.write(goIdent(c.Channel) + "[")
+		g.generateExpression(c.ChannelIndex)
+		g.write("]")
+	} else {
+		g.write(goIdent(c.Channel))
+	}
+	g.write(")}\n")
+
+	g.indent--
+	g.writeLine("}")
+
+	// Call reflect.Select
+	g.writeLine("_altChosen, _altValue, _ := reflect.Select(_altCases)")
+
+	// Recompute replicator variable from chosen index
+	g.builder.WriteString(strings.Repeat("\t", g.indent))
+	if rep.Step != nil {
+		g.write(fmt.Sprintf("%s := ", v))
+		g.generateExpression(rep.Start)
+		g.write(" + _altChosen * (")
+		g.generateExpression(rep.Step)
+		g.write(")\n")
+	} else {
+		g.write(fmt.Sprintf("%s := ", v))
+		g.generateExpression(rep.Start)
+		g.write(" + _altChosen\n")
+	}
+	g.writeLine(fmt.Sprintf("_ = %s", v))
+
+	// Generate scoped var declarations
+	for _, decl := range c.Declarations {
+		if vd, ok := decl.(*ast.VarDecl); ok {
+			g.generateVarDecl(vd)
+		}
+	}
+
+	// Generate scoped abbreviations
+	for _, decl := range c.Declarations {
+		if abbr, ok := decl.(*ast.Abbreviation); ok {
+			g.generateAbbreviation(abbr)
+		}
+	}
+
+	// Assign received value from reflect.Value
+	g.writeLine(fmt.Sprintf("%s = _altValue.Interface().(%s)", goIdent(c.Variable), recvType))
+
+	// Generate body
+	for _, s := range c.Body {
+		g.generateStatement(s)
+	}
+
+	g.indent--
+	g.writeLine("}")
+}
+
 func (g *Generator) generateProcDecl(proc *ast.ProcDecl) {
 	// Track reference parameters for this procedure
 	oldRefParams := g.refParams
@@ -2418,6 +2551,72 @@ func (g *Generator) containsRetypes(stmt ast.Statement) bool {
 	return false
 }
 
+func (g *Generator) containsAltReplicator(stmt ast.Statement) bool {
+	switch s := stmt.(type) {
+	case *ast.AltBlock:
+		if s.Replicator != nil {
+			return true
+		}
+		for _, c := range s.Cases {
+			for _, inner := range c.Body {
+				if g.containsAltReplicator(inner) {
+					return true
+				}
+			}
+		}
+	case *ast.SeqBlock:
+		for _, inner := range s.Statements {
+			if g.containsAltReplicator(inner) {
+				return true
+			}
+		}
+	case *ast.ParBlock:
+		for _, inner := range s.Statements {
+			if g.containsAltReplicator(inner) {
+				return true
+			}
+		}
+	case *ast.ProcDecl:
+		for _, inner := range s.Body {
+			if g.containsAltReplicator(inner) {
+				return true
+			}
+		}
+	case *ast.FuncDecl:
+		for _, inner := range s.Body {
+			if g.containsAltReplicator(inner) {
+				return true
+			}
+		}
+	case *ast.WhileLoop:
+		for _, inner := range s.Body {
+			if g.containsAltReplicator(inner) {
+				return true
+			}
+		}
+	case *ast.IfStatement:
+		for _, choice := range s.Choices {
+			if choice.NestedIf != nil && g.containsAltReplicator(choice.NestedIf) {
+				return true
+			}
+			for _, inner := range choice.Body {
+				if g.containsAltReplicator(inner) {
+					return true
+				}
+			}
+		}
+	case *ast.CaseStatement:
+		for _, choice := range s.Choices {
+			for _, inner := range choice.Body {
+				if g.containsAltReplicator(inner) {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
 // walkStatements recursively walks a statement tree, applying fn to all expressions.
 // Returns true if fn returns true for any expression.
 func (g *Generator) walkStatements(stmt ast.Statement, fn func(ast.Expression) bool) bool {
diff --git a/codegen/e2e_concurrency_test.go b/codegen/e2e_concurrency_test.go
index 3125809..af86288 100644
--- a/codegen/e2e_concurrency_test.go
+++ b/codegen/e2e_concurrency_test.go
@@ -264,3 +264,92 @@ func TestE2EChanShorthand(t *testing.T) {
 		t.Errorf("expected %q, got %q", expected, output)
 	}
 }
+
+func TestE2E_ReplicatedAltBasic(t *testing.T) {
+	// Test replicated ALT: 3 channels, send on one, ALT selects it
+	occam := `SEQ
+  [3]CHAN OF INT cs:
+  INT result:
+  PAR
+    cs[1] ! 42
+    ALT i = 0 FOR 3
+      INT val:
+      cs[i] ? val
+        result := val
+  print.int(result)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "42\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_ReplicatedAltIndex(t *testing.T) {
+	// Test that the replicator variable is available in the body
+	occam := `SEQ
+  [3]CHAN OF INT cs:
+  INT chosen:
+  INT value:
+  PAR
+    cs[2] ! 99
+    ALT i = 0 FOR 3
+      INT val:
+      cs[i] ? val
+        SEQ
+          chosen := i
+          value := val
+  print.int(chosen)
+  print.int(value)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "2\n99\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_ReplicatedAltWithAbbreviation(t *testing.T) {
+	// Test replicated ALT with scoped abbreviation
+	occam := `SEQ
+  [4]CHAN OF INT cs:
+  INT result:
+  PAR
+    cs[2] ! 77
+    ALT j = 0 FOR 4
+      VAL INT X IS j:
+      INT val:
+      cs[X] ? val
+        result := val
+  print.int(result)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "77\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
+
+func TestE2E_ReplicatedAltByte(t *testing.T) {
+	// Test replicated ALT with BYTE channels
+	occam := `SEQ
+  [2]CHAN OF BYTE cs:
+  BYTE result:
+  PAR
+    cs[0] ! 'A'
+    ALT i = 0 FOR 2
+      BYTE ch:
+      cs[i] ? ch
+        result := ch
+  IF
+    result = 'A'
+      print.int(1)
+    TRUE
+      print.int(0)
+`
+	output := transpileCompileRun(t, occam)
+	expected := "1\n"
+	if output != expected {
+		t.Errorf("expected %q, got %q", expected, output)
+	}
+}
diff --git a/parser/parser.go b/parser/parser.go
index 8fbda71..dcc4f2e 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -1568,6 +1568,17 @@ func (p *Parser) parseReplicator() *ast.Replicator {
 func (p *Parser) parseAltBlock() *ast.AltBlock {
 	block := &ast.AltBlock{Token: p.curToken}
 
+	// Check for replicator: ALT i = start FOR count
+	if p.peekTokenIs(lexer.IDENT) {
+		p.nextToken() // move to identifier
+		if p.peekTokenIs(lexer.EQ) {
+			block.Replicator = p.parseReplicator()
+		} else {
+			p.addError("unexpected identifier after ALT")
+			return block
+		}
+	}
+
 	// Skip to next line
 	for p.peekTokenIs(lexer.NEWLINE) {
 		p.nextToken()
@@ -1637,9 +1648,37 @@ func (p *Parser) parseAltCases() []ast.AltCase {
 	return cases
 }
 
+func (p *Parser) isAltDeclStart() bool {
+	switch p.curToken.Type {
+	case lexer.INT_TYPE, lexer.BYTE_TYPE, lexer.BOOL_TYPE, lexer.REAL_TYPE, lexer.REAL32_TYPE, lexer.REAL64_TYPE:
+		return true
+	case lexer.VAL:
+		return true
+	case lexer.INITIAL:
+		return true
+	}
+	return false
+}
+
 func (p *Parser) parseAltCase() *ast.AltCase {
 	altCase := &ast.AltCase{}
 
+	// Parse scoped declarations before the channel input (e.g., BYTE ch:, VAL INT X IS expr:)
+	for p.isAltDeclStart() {
+		stmt := p.parseStatement()
+		if stmt != nil {
+			altCase.Declarations = append(altCase.Declarations, stmt)
+		}
+		// Advance past the end of the declaration
+		if !p.curTokenIs(lexer.NEWLINE) && !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
+			p.nextToken()
+		}
+		// Skip newlines to reach next token
+		for p.curTokenIs(lexer.NEWLINE) {
+			p.nextToken()
+		}
+	}
+
 	// Check for guard: expression & channel ? var
 	// For now, we expect: channel ? var (no guard support yet)
 	// or: guard & channel ? var
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 7ff9606..8d962b3 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -3188,3 +3188,127 @@ func TestMultiLineBooleanExpression(t *testing.T) {
 		t.Errorf("expected operator 'AND', got %q", binExpr.Operator)
 	}
 }
+
+func TestAltReplicator(t *testing.T) {
+	input := `ALT i = 0 FOR n
+  BYTE ch:
+  in[i] ? ch
+    SKIP
+`
+	l := lexer.New(input)
+	p := New(l)
+	program := p.ParseProgram()
+	checkParserErrors(t, p)
+
+	if len(program.Statements) != 1 {
+		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
+	}
+
+	alt, ok := program.Statements[0].(*ast.AltBlock)
+	if !ok {
+		t.Fatalf("expected AltBlock, got %T", program.Statements[0])
+	}
+
+	if alt.Replicator == nil {
+		t.Fatal("expected replicator, got nil")
+	}
+
+	if alt.Replicator.Variable != "i" {
+		t.Errorf("expected replicator variable 'i', got %q", alt.Replicator.Variable)
+	}
+
+	startLit, ok := alt.Replicator.Start.(*ast.IntegerLiteral)
+	if !ok {
+		t.Fatalf("expected IntegerLiteral for start, got %T", alt.Replicator.Start)
+	}
+	if startLit.Value != 0 {
+		t.Errorf("expected start 0, got %d", startLit.Value)
+	}
+
+	countIdent, ok := alt.Replicator.Count.(*ast.Identifier)
+	if !ok {
+		t.Fatalf("expected Identifier for count, got %T", alt.Replicator.Count)
+	}
+	if countIdent.Value != "n" {
+		t.Errorf("expected count 'n', got %q", countIdent.Value)
+	}
+
+	if len(alt.Cases) != 1 {
+		t.Fatalf("expected 1 case, got %d", len(alt.Cases))
+	}
+
+	c := alt.Cases[0]
+	if len(c.Declarations) != 1 {
+		t.Fatalf("expected 1 declaration, got %d", len(c.Declarations))
+	}
+	vd, ok := c.Declarations[0].(*ast.VarDecl)
+	if !ok {
+		t.Fatalf("expected VarDecl, got %T", c.Declarations[0])
+	}
+	if vd.Type != "BYTE" {
+		t.Errorf("expected type 'BYTE', got %q", vd.Type)
+	}
+	if len(vd.Names) != 1 || vd.Names[0] != "ch" {
+		t.Errorf("expected name 'ch', got %v", vd.Names)
+	}
+
+	if c.Channel != "in" {
+		t.Errorf("expected channel 'in', got %q", c.Channel)
+	}
+	if c.ChannelIndex == nil {
+		t.Fatal("expected channel index, got nil")
+	}
+	if c.Variable != "ch" {
+		t.Errorf("expected variable 'ch', got %q", c.Variable)
+	}
+}
+
+func TestAltReplicatorWithAbbreviation(t *testing.T) {
+	input := `ALT j = 0 FOR s
+  VAL INT X IS (j + 1):
+  INT any:
+  in[X] ? any
+    SKIP
+`
+	l := lexer.New(input)
+	p := New(l)
+	program := p.ParseProgram()
+	checkParserErrors(t, p)
+
+	alt, ok := program.Statements[0].(*ast.AltBlock)
+	if !ok {
+		t.Fatalf("expected AltBlock, got %T", program.Statements[0])
+	}
+
+	if alt.Replicator == nil {
+		t.Fatal("expected replicator, got nil")
+	}
+
+	c := alt.Cases[0]
+	if len(c.Declarations) != 2 {
+		t.Fatalf("expected 2 declarations, got %d", len(c.Declarations))
+	}
+
+	abbr, ok := c.Declarations[0].(*ast.Abbreviation)
+	if !ok {
+		t.Fatalf("expected Abbreviation, got %T", c.Declarations[0])
+	}
+	if abbr.Name != "X" {
+		t.Errorf("expected abbreviation name 'X', got %q", abbr.Name)
+	}
+
+	vd, ok := c.Declarations[1].(*ast.VarDecl)
+	if !ok {
+		t.Fatalf("expected VarDecl, got %T", c.Declarations[1])
+	}
+	if vd.Type != "INT" || vd.Names[0] != "any" {
+		t.Errorf("expected INT any, got %s %v", vd.Type, vd.Names)
+	}
+
+	if c.Channel != "in" {
+		t.Errorf("expected channel 'in', got %q", c.Channel)
+	}
+	if c.Variable != "any" {
+		t.Errorf("expected variable 'any', got %q", c.Variable)
+	}
+}

Switched to a new branch 'feat/alt-replicator'

7 files changed, 460 insertions(+), 5 deletions(-)

remote: 
remote: Create a pull request for 'feat/alt-replicator' on GitHub by visiting:        
remote:      https://github.com/codeassociates/occam2go/pull/new/feat/alt-replicator        
remote: 
To associate-1.github.com:codeassociates/occam2go.git
 * [new branch]      feat/alt-replicator -> feat/alt-replicator
branch 'feat/alt-replicator' set up to track 'origin/feat/alt-replicator'.

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

Switched to branch 'main'
Your branch is up to date with 'origin/main'.
From associate-1.github.com:codeassociates/occam2go
   3cbf1cd..5f68a88  main       -> origin/main
Updating 3cbf1cd..5f68a88
Fast-forward
 CLAUDE.md                       |   3 +-
 TODO.md                         |   2 +-
 ast/ast.go                      |   7 +-
 codegen/codegen.go              | 201 +++++++++++++++++++++++++++++++++++++++-
 codegen/e2e_concurrency_test.go |  89 ++++++++++++++++++
 parser/parser.go                |  39 ++++++++
 parser/parser_test.go           | 124 +++++++++++++++++++++++++
 7 files changed, 460 insertions(+), 5 deletions(-)