sqlite: drop the sqlc.arg fold, now that preprocessing handles it

#4537 rewrites sqlc's syntax to native placeholders above the engines, and
SQLite is one of the preprocessed dialects, so sqlc.arg() and @name never
reach the parser. The fold this branch carried is dead.

One gap follows from the pass's rule that a statement whose sqlc syntax
did not validate is copied through for the engine to parse: that assumes
the engine can parse it. SQLite cannot, so an invalid sqlc.arg() surfaced
as `near "(": syntax error` and the preprocessor's own diagnostics were
never reported -- from parseCatalog, since a schema file and a query file
are often the same file. On a parse failure the compiler now reports the
sqlc syntax errors recorded for that file, if any, in place of the failure
they produced.

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

Author: claude

internal/compiler/compile.go

@@ -48,7 +48,12 @@ func (c *Compiler) parseCatalog(schemas []string) error {
 		// but don't update the catalog - the database will be the source of truth
 		stmts, err := c.parser.Parse(strings.NewReader(contents))
 		if err != nil {
-			merr.Add(filename, contents, 0, err)
+			// A schema file and a query file are often the same file, so a
+			// query's sqlc syntax can fail here. Look for an explanation
+			// before reporting the syntax error it caused.
+			if reported := addSyntaxErrors(merr, filename, contents, preprocess.File(c.conf.Engine, contents)); !reported {
+				merr.Add(filename, contents, 0, err)
+			}
 			continue
 		}
 
@@ -111,7 +116,9 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 
 		stmts, err := c.parser.Parse(strings.NewReader(pp.Text))
 		if err != nil {
-			merr.Add(filename, src, 0, err)
+			if reported := addSyntaxErrors(merr, filename, src, pp); !reported {
+				merr.Add(filename, src, 0, err)
+			}
 			continue
 		}
 		for _, stmt := range stmts {
@@ -162,3 +169,32 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 		Queries: q,
 	}, nil
 }
+
+// addSyntaxErrors reports every sqlc syntax error the preprocessor recorded
+// for a file, in source order, and says whether there were any. Locations come
+// back in the rewritten text's coordinates, so they are mapped through Origin
+// to point at what the user wrote.
+//
+// A statement whose sqlc syntax did not validate is copied through for the
+// engine to parse, which assumes the engine can parse it. SQLite cannot: it
+// has no schema-qualified function call, so a bad sqlc.arg() is a syntax error
+// there rather than a call the preprocessor's message can be attached to.
+// These messages name the cause, so they are reported in place of the failure
+// they produced; anything else wrong with the file surfaces on the next run.
+func addSyntaxErrors(merr *multierr.Error, filename, src string, pp *preprocess.Result) bool {
+	var found bool
+	for _, stmt := range pp.Statements() {
+		if stmt.Err == nil {
+			continue
+		}
+		found = true
+		loc := pp.Origin(stmt.Start)
+		var e *sqlerr.Error
+		if errors.As(stmt.Err, &e) && e.Location != 0 {
+			loc = pp.Origin(e.Location)
+			e.Location = loc
+		}
+		merr.Add(filename, src, loc, stmt.Err)
+	}
+	return found
+}

internal/engine/sqlite/convert.go

@@ -17,9 +17,6 @@ import (
 // markers within it.
 type cc struct {
 	paramCount int
-	// folded holds the offset of every "sqlc.name(" call the parser rewrote
-	// so that meyer would accept it. See foldSqlcCalls.
-	folded map[int]bool
 }
 
 func todo(funcname string, n meyer.Node) *ast.TODO {
@@ -1050,13 +1047,7 @@ func (c *cc) convertFuncCall(n *meyer.FuncCall) ast.Node {
 	funcName := identifier(n.Name)
 	args := c.convertExprList(n.Args)
 
-	var schema string
-	if c.folded[n.Name.Pos()] {
-		schema = sqlcSchema
-		funcName = strings.TrimPrefix(funcName, sqlcSchema+"_")
-	}
-
-	if schema == "" && funcName == "coalesce" {
+	if funcName == "coalesce" {
 		return &ast.CoalesceExpr{
 			Args:     args,
 			Location: n.Pos(),
@@ -1065,8 +1056,7 @@ func (c *cc) convertFuncCall(n *meyer.FuncCall) ast.Node {
 
 	call := &ast.FuncCall{
 		Func: &ast.FuncName{
-			Schema: schema,
-			Name:   funcName,
+			Name: funcName,
 		},
 		Funcname: &ast.List{Items: []ast.Node{
 			&ast.String{Str: funcName},

internal/engine/sqlite/parse.go

@@ -3,12 +3,9 @@ package sqlite
 import (
 	"errors"
 	"io"
-	"strings"
 
 	meyer "github.com/sqlc-dev/meyer/ast"
-	"github.com/sqlc-dev/meyer/lexer"
 	"github.com/sqlc-dev/meyer/parser"
-	"github.com/sqlc-dev/meyer/token"
 
 	"github.com/sqlc-dev/sqlc/internal/source"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
@@ -27,7 +24,7 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) {
 	if err != nil {
 		return nil, err
 	}
-	src, folded := foldSqlcCalls(string(blob))
+	src := string(blob)
 	parsed, err := parser.ParseString(src)
 	if err != nil {
 		return nil, normalizeErr(err)
@@ -39,7 +36,7 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) {
 	// reads the "-- name:" annotation out of that range.
 	loc := 0
 	for _, raw := range parsed {
-		converter := &cc{folded: folded}
+		converter := &cc{}
 		out := converter.convert(raw)
 		if _, ok := out.(*ast.TODO); !ok {
 			stmts = append(stmts, ast.Statement{
@@ -55,52 +52,6 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) {
 	return stmts, nil
 }
 
-// sqlcSchema is the pseudo-schema sqlc's own functions are written under.
-const sqlcSchema = "sqlc"
-
-// foldSqlcCalls rewrites "sqlc.name(" to "sqlc_name(" and reports the offset
-// of every identifier it folded.
-//
-// SQLite has no schema-qualified function call, so sqlc.arg(), sqlc.narg(),
-// sqlc.slice() and sqlc.embed() are not SQL that meyer will parse. Folding
-// the dot into the name substitutes one byte for another, which leaves every
-// offset in the tree pointing at the same place in the original source;
-// convertFuncCall restores the schema for the calls listed here. Working from
-// the token stream rather than the raw text keeps the rewrite out of string
-// literals and comments.
-func foldSqlcCalls(src string) (string, map[int]bool) {
-	toks := lexer.Lex(src)
-	var out []byte
-	var folded map[int]bool
-	for i := 0; i+3 < len(toks); i++ {
-		if toks[i].Kind != token.ID || toks[i+1].Kind != token.DOT || toks[i+3].Kind != token.LP {
-			continue
-		}
-		if name := toks[i+2].Kind; name != token.ID && !token.CanFallback(name) {
-			continue
-		}
-		// The three tokens have to be written as one word for the fold to
-		// produce one. Anything else is left to fail as the syntax error it
-		// is, rather than silently reparsed as something else.
-		if toks[i].End != toks[i+1].Pos || toks[i+1].End != toks[i+2].Pos {
-			continue
-		}
-		if !strings.EqualFold(src[toks[i].Pos:toks[i].End], sqlcSchema) {
-			continue
-		}
-		if out == nil {
-			out = []byte(src)
-			folded = map[int]bool{}
-		}
-		out[toks[i+1].Pos] = '_'
-		folded[toks[i].Pos] = true
-	}
-	if out == nil {
-		return src, nil
-	}
-	return string(out), folded
-}
-
 // trimTerminator returns the end of stmt with its terminating semicolon, and
 // any space before it, removed. A statement's span runs through the
 // semicolon, but sqlc's statement text does not include it.