fix: diagnostic panics and lambda file name

Bounds-check span data before slicing source strings in
diagnostic creation. Invalid spans (from stale AST or
converter edge cases) would panic on out-of-range access,
crashing the LSP server during editing.

Thread the script file name through FindCmdBlocks into the
lambda converter. The eager conversion in step 7 lost the
file parameter, causing error messages from command lambda
callbacks to show <stdin> instead of the script name.

Author: amterp

core/script_meta.go

@@ -54,7 +54,7 @@ func ExtractMetadata(src string) *ScriptData {
 	}
 
 	var commands []*ScriptCommand
-	if cmdBlocks, ok := tree.FindCmdBlocks(); ok {
+	if cmdBlocks, ok := tree.FindCmdBlocks(ScriptName); ok {
 		RP.RadDebugf(fmt.Sprintf("Found %d command blocks", len(cmdBlocks)))
 		commands = extractCommands(cmdBlocks)
 	}

rts/check/ast_checks.go

@@ -427,7 +427,7 @@ func (c *RadCheckerImpl) validateAssignmentTargetAST(node rl.Node, d *[]Diagnost
 		// Valid assignment targets
 		return
 	case *rl.LitInt, *rl.LitFloat, *rl.LitString, *rl.LitBool, *rl.LitNull:
-		content := c.src[node.Span().StartByte:node.Span().EndByte]
+		content := safeSlice(c.src, node.Span().StartByte, node.Span().EndByte)
 		msg := "Cannot assign to literal '" + truncate(content, 20) + "'"
 		*d = append(*d, NewDiagnosticErrorFromSpan(node.Span(), c.src, msg, rl.ErrInvalidAssignmentTarget))
 	case *rl.Call:
@@ -437,7 +437,7 @@ func (c *RadCheckerImpl) validateAssignmentTargetAST(node rl.Node, d *[]Diagnost
 		msg := "Cannot assign to expression"
 		*d = append(*d, NewDiagnosticErrorFromSpan(node.Span(), c.src, msg, rl.ErrInvalidAssignmentTarget))
 	default:
-		content := c.src[node.Span().StartByte:node.Span().EndByte]
+		content := safeSlice(c.src, node.Span().StartByte, node.Span().EndByte)
 		msg := "Cannot assign to '" + truncate(content, 20) + "'"
 		*d = append(*d, NewDiagnosticErrorFromSpan(node.Span(), c.src, msg, rl.ErrInvalidAssignmentTarget))
 	}

rts/check/check.go

@@ -310,7 +310,7 @@ func (c *RadCheckerImpl) addUnknownCommandCallbackWarnings(d *[]Diagnostic) {
 		hoistedFunctionSet[fnName] = true
 	}
 
-	cmdBlocks, ok := c.tree.FindCmdBlocks()
+	cmdBlocks, ok := c.tree.FindCmdBlocks("")
 	if !ok {
 		return
 	}

rts/check/structs.go

@@ -113,18 +113,36 @@ func NewDiagnosticFromSpan(
 			Character: span.EndCol,
 		},
 	}
-	lineSrc := strings.Split(originalSrc, "\n")[line]
+	lines := strings.Split(originalSrc, "\n")
+	lineSrc := ""
+	if line >= 0 && line < len(lines) {
+		lineSrc = lines[line]
+	}
 	return Diagnostic{
 		OriginalSrc: originalSrc,
 		Range:       rang,
-		RangedSrc:   originalSrc[span.StartByte:span.EndByte],
+		RangedSrc:   safeSlice(originalSrc, span.StartByte, span.EndByte),
 		LineSrc:     lineSrc,
 		Severity:    severity,
 		Message:     msg,
 		Code:        code,
 	}
 }
 
+// safeSlice returns src[start:end] with bounds clamped to [0, len(src)].
+func safeSlice(src string, start, end int) string {
+	if start < 0 {
+		start = 0
+	}
+	if end > len(src) {
+		end = len(src)
+	}
+	if start > end {
+		start = end
+	}
+	return src[start:end]
+}
+
 func NewDiagnosticErrorFromSpan(span rl.Span, originalSrc string, msg string, code rl.Error) Diagnostic {
 	return NewDiagnosticFromSpan(span, originalSrc, Error, msg, &code)
 }

rts/nodes_commands.go

@@ -47,8 +47,9 @@ type CmdCallback struct {
 	LambdaAST       *rl.Lambda // Eagerly converted AST for lambda callbacks
 }
 
-// newCmdBlock constructs a CmdBlock from a tree-sitter node
-func newCmdBlock(src string, node *ts.Node) (*CmdBlock, bool) {
+// newCmdBlock constructs a CmdBlock from a tree-sitter node.
+// file is threaded to the lambda converter for span metadata.
+func newCmdBlock(src string, node *ts.Node, file string) (*CmdBlock, bool) {
 	// Extract command name
 	nameNode := node.ChildByFieldName(rl.F_NAME)
 	if nameNode == nil {
@@ -82,7 +83,7 @@ func newCmdBlock(src string, node *ts.Node) (*CmdBlock, bool) {
 	exclusions := findArgExclusions(src, node)
 
 	// Extract callback
-	callback := extractCmdCallback(src, node)
+	callback := extractCmdCallback(src, node, file)
 
 	return &CmdBlock{
 		BaseNode:         newBaseNode(src, node),
@@ -98,8 +99,9 @@ func newCmdBlock(src string, node *ts.Node) (*CmdBlock, bool) {
 	}, true
 }
 
-// extractCmdCallback extracts the callback from a cmd_calls node
-func extractCmdCallback(src string, node *ts.Node) CmdCallback {
+// extractCmdCallback extracts the callback from a cmd_calls node.
+// file is used for span metadata in eagerly-converted lambda AST.
+func extractCmdCallback(src string, node *ts.Node, file string) CmdCallback {
 	callsNode := node.ChildByFieldName(rl.F_CALLS)
 	if callsNode == nil {
 		panic(fmt.Sprintf("Bug! Command block missing 'calls' field at byte %d", node.StartByte()))
@@ -128,7 +130,7 @@ func extractCmdCallback(src string, node *ts.Node) CmdCallback {
 	// Check for lambda callback
 	lambdaNode := callsNode.ChildByFieldName(rl.F_CALLBACK_LAMBDA)
 	if lambdaNode != nil {
-		lambdaAST := safeConvertLambda(lambdaNode, src)
+		lambdaAST := safeConvertLambda(lambdaNode, src, file)
 		return CmdCallback{
 			BaseNode:  newBaseNode(src, callsNode),
 			Type:      CallbackLambda,
@@ -141,11 +143,11 @@ func extractCmdCallback(src string, node *ts.Node) CmdCallback {
 
 // safeConvertLambda converts a lambda CST node to AST, recovering from panics
 // caused by malformed syntax. Returns nil if conversion fails.
-func safeConvertLambda(lambdaNode *ts.Node, src string) (result *rl.Lambda) {
+func safeConvertLambda(lambdaNode *ts.Node, src, file string) (result *rl.Lambda) {
 	defer func() {
 		if r := recover(); r != nil {
 			result = nil
 		}
 	}()
-	return ConvertLambda(lambdaNode, src, "")
+	return ConvertLambda(lambdaNode, src, file)
 }

rts/rts_tree.go

@@ -70,7 +70,7 @@ func (rt *RadTree) FindArgBlock() (*ArgBlock, bool) {
 	return argBlocks[0], true // todo bad if multiple
 }
 
-func (rt *RadTree) FindCmdBlocks() ([]*CmdBlock, bool) {
+func (rt *RadTree) FindCmdBlocks(file string) ([]*CmdBlock, bool) {
 	// Commands can appear multiple times, so we need to find all of them
 	nodes := rt.FindNodes(rl.K_CMD_BLOCK)
 	if len(nodes) == 0 {
@@ -79,7 +79,7 @@ func (rt *RadTree) FindCmdBlocks() ([]*CmdBlock, bool) {
 
 	cmdBlocks := make([]*CmdBlock, 0, len(nodes))
 	for _, node := range nodes {
-		cmdBlock, ok := newCmdBlock(rt.src, node)
+		cmdBlock, ok := newCmdBlock(rt.src, node, file)
 		if ok {
 			cmdBlocks = append(cmdBlocks, cmdBlock)
 		}
@@ -201,7 +201,7 @@ func createNode[T Node](src string, node *ts.Node) (T, bool) {
 		argBlock, _ := newArgBlock(src, node)
 		return any(argBlock).(T), true
 	case *CmdBlock:
-		cmdBlock, _ := newCmdBlock(src, node)
+		cmdBlock, _ := newCmdBlock(src, node, "")
 		return any(cmdBlock).(T), true
 	case *StringNode:
 		stringNode, _ := newStringNode(src, node)