Replace C Lua interpreter with new interpreter

`CGO_ENABLED=0 go build ./cmd/zb` now runs. 🎉

Fixes #28

Author: zombiezen

internal/frontend/derivation_eval.go

@@ -6,7 +6,6 @@ package frontend
 import (
 	"context"
 	"fmt"
-	"runtime/cgo"
 	"strings"
 
 	"zb.256lights.llc/pkg/internal/jsonrpc"
@@ -24,7 +23,6 @@ func registerDerivationMetatable(l *lua.State) {
 	err := lua.SetFuncs(l, 0, map[string]lua.Function{
 		"__index":     indexDerivation,
 		"__pairs":     derivationPairs,
-		"__gc":        gcDerivation,
 		"__tostring":  derivationToString,
 		"__concat":    concatDerivation,
 		"__metatable": nil, // prevent Lua access to metatable
@@ -203,17 +201,15 @@ func (eval *Eval) derivationFunction(ctx context.Context, l *lua.State) (int, er
 			DrvPath:    drvPath,
 			OutputName: outputName,
 		}
-		l.PushStringContext(placeholder, []string{contextValue{outputReference: ref}.String()})
+		l.PushStringContext(placeholder, sets.New(contextValue{outputReference: ref}.String()))
 		if err := l.SetField(tableCopyIndex, outputName, 0); err != nil {
 			return 0, fmt.Errorf("derivation: %v", err)
 		}
 	}
 
-	l.NewUserdataUV(8, 1)
+	l.NewUserdata(drv, 1)
 	l.Rotate(-2, -1) // Swap userdata and argument table copy.
 	l.SetUserValue(-2, 1)
-	handle := cgo.NewHandle(drv)
-	setUserdataHandle(l, -1, handle)
 
 	lua.SetMetatable(l, derivationTypeName)
 
@@ -277,7 +273,7 @@ func stringToEnvVar(l *lua.State, drv *zbstore.Derivation, idx int) (string, err
 	l.PushValue(idx) // Clone so that we don't munge a number.
 	defer l.Pop(1)
 	s, _ := l.ToString(-1)
-	for _, dep := range l.StringContext(-1) {
+	for dep := range l.StringContext(-1).All() {
 		c, err := parseContextString(dep)
 		if err != nil {
 			return "", fmt.Errorf("internal error: %v", err)
@@ -359,30 +355,11 @@ func toDerivation(l *lua.State) (*zbstore.Derivation, error) {
 }
 
 func testDerivation(l *lua.State, idx int) *zbstore.Derivation {
-	handle, _ := testUserdataHandle(l, idx, derivationTypeName)
-	if handle == 0 {
-		return nil
-	}
-	drv, _ := handle.Value().(*zbstore.Derivation)
+	x, _ := lua.TestUserdata(l, idx, derivationTypeName)
+	drv, _ := x.(*zbstore.Derivation)
 	return drv
 }
 
-// gcDerivation handles the __gc metamethod on derivations
-// by releasing the [*derivation].
-func gcDerivation(l *lua.State) (int, error) {
-	const idx = 1
-	handle, ok := testUserdataHandle(l, idx, derivationTypeName)
-	if !ok {
-		return 0, lua.NewTypeError(l, idx, derivationTypeName)
-	}
-	if handle == 0 {
-		return 0, nil
-	}
-	handle.Delete()
-	setUserdataHandle(l, idx, 0)
-	return 0, nil
-}
-
 // indexDerivation handles the __index metamethod on derivations.
 func indexDerivation(l *lua.State) (int, error) {
 	if _, err := toDerivation(l); err != nil {
@@ -497,5 +474,5 @@ func (c contextValue) String() string {
 }
 
 func pushStorePath(l *lua.State, path zbstore.Path) {
-	l.PushStringContext(string(path), []string{contextValue{path: path}.String()})
+	l.PushStringContext(string(path), sets.New(contextValue{path: path}.String()))
 }

internal/frontend/eval.go

@@ -4,17 +4,16 @@
 package frontend
 
 import (
+	"bufio"
 	"context"
 	"embed"
-	"encoding/binary"
 	"errors"
 	"fmt"
 	"io"
 	"io/fs"
 	"os"
 	slashpath "path"
 	"path/filepath"
-	"runtime/cgo"
 	"strings"
 
 	"zb.256lights.llc/pkg/internal/jsonrpc"
@@ -72,7 +71,9 @@ func NewEval(storeDir zbstore.Directory, store *jsonrpc.Client, cacheDB string)
 
 	registerDerivationMetatable(&eval.l)
 
-	base := lua.NewOpenBase(io.Discard, nil)
+	base := lua.NewOpenBase(&lua.BaseOptions{
+		Output: io.Discard,
+	})
 	if err := lua.Require(&eval.l, lua.GName, true, base); err != nil {
 		return nil, err
 	}
@@ -123,7 +124,7 @@ func NewEval(storeDir zbstore.Directory, store *jsonrpc.Client, cacheDB string)
 	}
 
 	// Run prelude.
-	if err := eval.l.LoadString(preludeSource, "=(prelude)", "t"); err != nil {
+	if err := eval.l.Load(strings.NewReader(preludeSource), lua.AbstractSource("(prelude)"), "t"); err != nil {
 		return nil, err
 	}
 	if err := eval.l.Call(0, 0, 0); err != nil {
@@ -258,7 +259,6 @@ func (eval *Eval) File(ctx context.Context, exprFile string, attrPaths []string)
 		return nil, err
 	}
 	if err := eval.l.Call(0, 1, 0); err != nil {
-		eval.l.Pop(1)
 		return nil, err
 	}
 	return eval.attrPaths(attrPaths)
@@ -281,7 +281,6 @@ func (eval *Eval) Expression(ctx context.Context, expr string, attrPaths []strin
 		return nil, err
 	}
 	if err := eval.l.Call(0, 1, 0); err != nil {
-		eval.l.Pop(1)
 		return nil, err
 	}
 	return eval.attrPaths(attrPaths)
@@ -305,13 +304,12 @@ func (eval *Eval) attrPaths(paths []string) ([]any, error) {
 			expr += "."
 		}
 		expr += p + ";"
-		if err := eval.l.LoadString(expr, expr, "t"); err != nil {
+		if err := eval.l.Load(strings.NewReader(expr), lua.LiteralSource(expr), "t"); err != nil {
 			eval.l.Pop(1)
 			return result, fmt.Errorf("%s: %v", p, err)
 		}
 		eval.l.PushValue(-2)
 		if err := eval.l.Call(1, 1, 0); err != nil {
-			eval.l.Pop(1)
 			return result, fmt.Errorf("%s: %v", p, err)
 		}
 		x, err := luaToGo(&eval.l)
@@ -389,20 +387,6 @@ func luaToGo(l *lua.State) (any, error) {
 	}
 }
 
-func testUserdataHandle(l *lua.State, idx int, tname string) (cgo.Handle, bool) {
-	data := lua.TestUserdata(l, idx, tname)
-	if len(data) != 8 {
-		return 0, false
-	}
-	return cgo.Handle(binary.LittleEndian.Uint64(data)), true
-}
-
-func setUserdataHandle(l *lua.State, idx int, handle cgo.Handle) {
-	var buf [8]byte
-	binary.LittleEndian.PutUint64(buf[:], uint64(handle))
-	l.SetUserdata(idx, 0, buf[:])
-}
-
 func loadFile(l *lua.State, path string) error {
 	path, err := filepath.Abs(path)
 	if err != nil {
@@ -414,19 +398,19 @@ func loadFile(l *lua.State, path string) error {
 	}
 	defer f.Close()
 
-	if err := l.Load(f, "@"+path, "t"); err != nil {
+	if err := l.Load(bufio.NewReader(f), lua.FilenameSource(path), "t"); err != nil {
 		l.Pop(1)
 		return fmt.Errorf("load file %s: %w", path, err)
 	}
 	return nil
 }
 
 func loadExpression(l *lua.State, expr string) error {
-	if err := l.LoadString("return "+expr+";", expr, "t"); err == nil {
+	if err := l.Load(strings.NewReader("return "+expr+";"), lua.LiteralSource(expr), "t"); err == nil {
 		return nil
 	}
 	l.Pop(1)
-	if err := l.LoadString(expr, expr, "t"); err != nil {
+	if err := l.Load(strings.NewReader(expr), lua.LiteralSource(expr), "t"); err != nil {
 		l.Pop(1)
 		return err
 	}
@@ -495,7 +479,7 @@ func (eval *Eval) loadfileFunction(ctx context.Context, l *lua.State) (int, erro
 	// TODO(someday): If we have dependencies and we're using a non-local store,
 	// export the store object and read it.
 	var rewrites []string
-	for _, dep := range filenameContext {
+	for dep := range filenameContext {
 		c, err := parseContextString(dep)
 		if err != nil {
 			l.PushNil()

internal/frontend/path_eval.go

@@ -16,6 +16,7 @@ import (
 
 	"zb.256lights.llc/pkg/internal/jsonrpc"
 	"zb.256lights.llc/pkg/internal/lua"
+	"zb.256lights.llc/pkg/sets"
 	"zb.256lights.llc/pkg/zbstore"
 	"zombiezen.com/go/log"
 	"zombiezen.com/go/nix"
@@ -26,7 +27,7 @@ import (
 
 func (eval *Eval) pathFunction(ctx context.Context, cache *sqlite.Conn, l *lua.State) (nResults int, err error) {
 	var p string
-	var pcontext []string
+	var pcontext sets.Set[string]
 	var name string
 	switch l.Type(1) {
 	case lua.TypeString:
@@ -226,7 +227,7 @@ func (eval *Eval) toFileFunction(ctx context.Context, l *lua.State) (int, error)
 	h := nix.NewHasher(nix.SHA256)
 	h.WriteString(s)
 	var refs zbstore.References
-	for _, dep := range l.StringContext(2) {
+	for dep := range l.StringContext(2) {
 		c, err := parseContextString(dep)
 		if err != nil {
 			return 0, fmt.Errorf("internal error: %v", err)
@@ -297,7 +298,7 @@ func writeSingleFileNAR(w io.Writer, r io.Reader, sz int64) error {
 
 // absSourcePath takes a source path passed as an argument from Lua to Go
 // and resolves it relative to the calling function.
-func absSourcePath(l *lua.State, path string, context []string) (string, error) {
+func absSourcePath(l *lua.State, path string, context sets.Set[string]) (string, error) {
 	if filepath.IsAbs(path) {
 		return path, nil
 	}
@@ -306,7 +307,7 @@ func absSourcePath(l *lua.State, path string, context []string) (string, error)
 		// Such placeholders have a leading slash, followed by a long hash digest.
 		// On non-POSIX systems, such a path might not be recognized as an absolute path.
 		// We treat this as an absolute path while preserving the placeholder.
-		for _, dep := range context {
+		for dep := range context {
 			c, err := parseContextString(dep)
 			if err != nil {
 				return "", fmt.Errorf("resolve path: internal error: %v", err)
@@ -329,12 +330,13 @@ func absSourcePath(l *lua.State, path string, context []string) (string, error)
 		}
 	}
 
-	// TODO(maybe): This is probably wonky with tail calls.
-	debugInfo := l.Stack(1).Info("S")
+	// Lua guarantees that a call to a native function will never be a tail call,
+	// so we can always get information about the immediate caller.
+	debugInfo := l.Info(1)
 	if debugInfo == nil {
 		return "", fmt.Errorf("resolve path: no caller information available")
 	}
-	source, ok := strings.CutPrefix(debugInfo.Source, "@")
+	source, ok := debugInfo.Source.Filename()
 	if !ok {
 		// Not loaded from a file. Use working directory.
 		//