core/analyzer: bind FROM items against the scope being built

A set-returning function in FROM takes its arguments from the items before
it, so bindRangeFunction types the call while the scope is still being
assembled. The scope under construction was never installed on the analyzer,
so a.scope was nil and resolving one of those arguments dereferenced it:

    FROM transactions,
         jsonb_each(jsonb_extract_path(transactions.data, '...')) AS x

buildScope and relationScope now install the scope they are filling for as
long as they fill it, and put back the one they replaced on the way out.
Resolving against a nil scope also reports the column as unresolved rather
than crashing, so no other half-built statement can panic on the way to the
error it was going to report anyway.

Both queries now analyze to an ordinary error instead of taking down the
process, which is what the rest of the corpus needed: TestReplay's core
context runs to completion in one process rather than aborting partway.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0161e7oMkzNW9DZMUPtyQibH

Author: claude

internal/core/analyzer/dml.go

@@ -83,6 +83,7 @@ func (a *analyzer) analyzeDelete(s *ast.DeleteStmt) error {
 // report a multi-table DELETE that way — a single FROM node.
 func (a *analyzer) relationScope(relations, extra *ast.List, from ast.Node) (*scope, error) {
 	sc := &scope{}
+	defer a.binding(sc)()
 	for _, item := range listItems(relations) {
 		if err := a.appendFromItem(sc, item); err != nil {
 			return nil, err

internal/core/analyzer/scope.go

@@ -22,6 +22,7 @@ type scopeRel struct {
 func (a *analyzer) buildScope(from *ast.List) (*scope, error) {
 	items := listItems(from)
 	sc := &scope{rels: make([]scopeRel, 0, len(items))}
+	defer a.binding(sc)()
 	for _, item := range items {
 		if err := a.appendFromItem(sc, item); err != nil {
 			return nil, err
@@ -30,6 +31,17 @@ func (a *analyzer) buildScope(from *ast.List) (*scope, error) {
 	return sc, nil
 }
 
+// binding makes the scope under construction the one the analyzer resolves
+// against, and returns the func that puts back the scope it replaced. A FROM
+// item can refer to the ones before it — a set-returning function takes its
+// arguments from them — so binding an item has to see what is bound so far
+// rather than no scope at all.
+func (a *analyzer) binding(sc *scope) func() {
+	prev := a.scope
+	a.scope = sc
+	return func() { a.scope = prev }
+}
+
 func (a *analyzer) appendFromItem(sc *scope, item ast.Node) error {
 	switch v := item.(type) {
 	case *ast.RangeVar:
@@ -202,6 +214,12 @@ func (a *analyzer) resolveColumn(relation, column string) (scopeRel, core.ClassC
 // relation. It reports an error when more than one relation in scope offers
 // that name.
 func (s *scope) resolveColumn(relation, column string) (rel scopeRel, col core.ClassColumn, ok bool, err error) {
+	// A statement whose scope is not built yet offers no columns. Report the
+	// column as unresolved and let the caller say so, rather than crashing on
+	// the way to the same answer.
+	if s == nil {
+		return rel, col, false, nil
+	}
 	found := 0
 	for _, r := range s.rels {
 		if relation != "" && r.alias != relation {