feat: add semantic grammar checks for control flow

Implement three semantic checks that tree-sitter cannot detect:

1. break/continue outside loop: Tracks loop depth and reports errors
   when break/continue appear at top level

2. return/yield outside context: return requires function context;
   yield is valid in both functions and switch expressions

3. Invalid assignment targets: Detects attempts to assign to literals,
   function calls, or expressions (e.g., "1 = 2" or "foo() = bar")

Add error codes: ErrReturnOutsideFunction, ErrYieldOutsideFunction,
ErrInvalidAssignmentTarget

Author: amterp

rts/check/check.go

@@ -60,6 +60,10 @@ func (c *RadCheckerImpl) Check(opts Opts) (Result, error) {
 	c.addFunctionNameShadowingErrors(&diagnostics)
 	c.addUnknownFunctionHints(&diagnostics)
 	c.addUnknownCommandCallbackWarnings(&diagnostics)
+	// Semantic grammar checks
+	c.addBreakContinueOutsideLoopErrors(&diagnostics)
+	c.addReturnOutsideFunctionErrors(&diagnostics)
+	c.addInvalidAssignmentLHSErrors(&diagnostics)
 	return Result{
 		Diagnostics: diagnostics,
 	}, nil
@@ -319,3 +323,193 @@ func (c *RadCheckerImpl) addUnknownCommandCallbackWarnings(d *[]Diagnostic) {
 		*d = append(*d, NewDiagnosticWarn(identifierNode, c.src, msg, rl.ErrUnknownFunction))
 	}
 }
+
+// addBreakContinueOutsideLoopErrors checks for break/continue statements outside of loops.
+func (c *RadCheckerImpl) addBreakContinueOutsideLoopErrors(d *[]Diagnostic) {
+	root := c.tree.Root()
+	c.walkForBreakContinue(root, d, 0)
+}
+
+func (c *RadCheckerImpl) walkForBreakContinue(node *ts.Node, d *[]Diagnostic, loopDepth int) {
+	if node == nil {
+		return
+	}
+
+	kind := node.Kind()
+
+	// Track loop entry
+	newLoopDepth := loopDepth
+	if kind == rl.K_FOR_LOOP || kind == rl.K_WHILE_LOOP {
+		newLoopDepth++
+	}
+
+	// Check for break/continue outside loop
+	if kind == rl.K_BREAK_STMT {
+		if loopDepth == 0 {
+			msg := "'break' can only be used inside a loop"
+			*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrBreakOutsideLoop))
+		}
+	} else if kind == rl.K_CONTINUE_STMT {
+		if loopDepth == 0 {
+			msg := "'continue' can only be used inside a loop"
+			*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrContinueOutsideLoop))
+		}
+	}
+
+	// Recursively walk children
+	for i := uint(0); i < node.ChildCount(); i++ {
+		c.walkForBreakContinue(node.Child(i), d, newLoopDepth)
+	}
+}
+
+// addReturnOutsideFunctionErrors checks for return statements outside of functions.
+func (c *RadCheckerImpl) addReturnOutsideFunctionErrors(d *[]Diagnostic) {
+	root := c.tree.Root()
+	c.walkForReturn(root, d, false, false)
+}
+
+// walkForReturn tracks both function context and switch/yield context.
+// yieldContext is true when inside a switch expression (where yield is valid).
+func (c *RadCheckerImpl) walkForReturn(node *ts.Node, d *[]Diagnostic, inFunction, inYieldContext bool) {
+	if node == nil {
+		return
+	}
+
+	kind := node.Kind()
+
+	// Track context changes
+	newInFunction := inFunction
+	newInYieldContext := inYieldContext
+
+	if kind == rl.K_FN_NAMED || kind == rl.K_FN_LAMBDA {
+		newInFunction = true
+	}
+
+	// Switch expressions create a yield context (yield produces the switch result)
+	if kind == rl.K_SWITCH_STMT {
+		newInYieldContext = true
+	}
+
+	// Check for return outside function
+	if kind == rl.K_RETURN_STMT {
+		if !inFunction {
+			msg := "'return' can only be used inside a function"
+			*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrReturnOutsideFunction))
+		}
+	}
+
+	// Check yield - valid inside functions OR switch expressions
+	if kind == rl.K_YIELD_STMT {
+		if !inFunction && !inYieldContext {
+			msg := "'yield' can only be used inside a function or switch expression"
+			*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrYieldOutsideFunction))
+		}
+	}
+
+	// Recursively walk children
+	for i := uint(0); i < node.ChildCount(); i++ {
+		c.walkForReturn(node.Child(i), d, newInFunction, newInYieldContext)
+	}
+}
+
+// addInvalidAssignmentLHSErrors checks for invalid assignment targets.
+func (c *RadCheckerImpl) addInvalidAssignmentLHSErrors(d *[]Diagnostic) {
+	root := c.tree.Root()
+	c.walkForAssignments(root, d)
+}
+
+func (c *RadCheckerImpl) walkForAssignments(node *ts.Node, d *[]Diagnostic) {
+	if node == nil {
+		return
+	}
+
+	if node.Kind() == rl.K_ASSIGN {
+		c.checkAssignmentLHS(node, d)
+	}
+
+	// Recursively walk children
+	for i := uint(0); i < node.ChildCount(); i++ {
+		c.walkForAssignments(node.Child(i), d)
+	}
+}
+
+func (c *RadCheckerImpl) checkAssignmentLHS(assignNode *ts.Node, d *[]Diagnostic) {
+	// Get the left-hand side(s) of the assignment
+	lefts := assignNode.ChildrenByFieldName(rl.F_LEFTS, assignNode.Walk())
+	if len(lefts) == 0 {
+		// Single left
+		left := assignNode.ChildByFieldName(rl.F_LEFT)
+		if left != nil {
+			c.validateAssignmentTarget(left, d)
+		}
+		return
+	}
+
+	// Multiple lefts (unpacking)
+	for i := range lefts {
+		c.validateAssignmentTarget(&lefts[i], d)
+	}
+}
+
+func (c *RadCheckerImpl) validateAssignmentTarget(node *ts.Node, d *[]Diagnostic) {
+	if node == nil {
+		return
+	}
+
+	kind := node.Kind()
+
+	// Valid assignment targets:
+	// - identifier (x = 1)
+	// - var_path (x.y = 1 or x[0] = 1)
+	// - indexed_expr (x[0] = 1)
+
+	switch kind {
+	case rl.K_IDENTIFIER, rl.K_VAR_PATH, rl.K_INDEXED_EXPR:
+		// These are valid assignment targets
+		return
+	case rl.K_INT, rl.K_FLOAT, rl.K_STRING, rl.K_BOOL, rl.K_NULL:
+		// Literals cannot be assigned to
+		content := c.src[node.StartByte():node.EndByte()]
+		msg := "Cannot assign to literal '" + truncate(content, 20) + "'"
+		*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrInvalidAssignmentTarget))
+	case rl.K_CALL:
+		// Function calls cannot be assigned to
+		msg := "Cannot assign to function call result"
+		*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrInvalidAssignmentTarget))
+	case rl.K_ADD_EXPR, rl.K_MULT_EXPR, rl.K_COMPARE_EXPR, rl.K_OR_EXPR, rl.K_AND_EXPR, rl.K_TERNARY_EXPR:
+		// Expressions cannot be assigned to
+		msg := "Cannot assign to expression"
+		*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrInvalidAssignmentTarget))
+	case rl.K_PARENTHESIZED_EXPR:
+		// Check inside parentheses
+		inner := node.ChildByFieldName(rl.F_EXPR)
+		if inner != nil {
+			c.validateAssignmentTarget(inner, d)
+		}
+	default:
+		// For any other unexpected node type
+		if !isValidAssignmentTarget(kind) {
+			content := c.src[node.StartByte():node.EndByte()]
+			msg := "Cannot assign to '" + truncate(content, 20) + "'"
+			*d = append(*d, NewDiagnosticError(node, c.src, msg, rl.ErrInvalidAssignmentTarget))
+		}
+	}
+}
+
+// isValidAssignmentTarget returns true if the node kind is a valid LHS for assignment.
+func isValidAssignmentTarget(kind string) bool {
+	switch kind {
+	case rl.K_IDENTIFIER, rl.K_VAR_PATH, rl.K_INDEXED_EXPR:
+		return true
+	default:
+		return false
+	}
+}
+
+// truncate shortens a string to maxLen, adding "..." if truncated.
+func truncate(s string, maxLen int) string {
+	if len(s) <= maxLen {
+		return s
+	}
+	return s[:maxLen-3] + "..."
+}

rts/rl/errors.go

@@ -94,6 +94,9 @@ const (
 	ErrScientificNotationNotWholeNumber Error = "40001"
 	ErrHoistedFunctionShadowsArgument   Error = "40002"
 	ErrUnknownFunction                  Error = "40003"
+	ErrReturnOutsideFunction            Error = "40004"
+	ErrYieldOutsideFunction             Error = "40005"
+	ErrInvalidAssignmentTarget          Error = "40006"
 )
 
 func (e Error) String() string {