lua

package module
v1.5.11 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 21, 2026 License: MIT Imports: 28 Imported by: 0

README ¶

go-lua

Heavily modified Fork of gopher-lua. Lua 5.1 VM with integers/bitwise from 5.3, plus a custom flow-sensitive type checker. Optimized for actor runtimes with shared immutable stdlib and low per-state overhead.

go get github.com/wippyai/go-lua

Type Annotations

local x: number = 42
local name: string = "alice"
local items: {number} = {1, 2, 3}
local lookup: {[string]: number} = {a = 1, b = 2}

type Point = {x: number, y: number}
local p: Point = {x = 10, y = 20}

local fn: (number, number) -> number = function(a, b) return a + b end

Generics

local function first<T>(arr: {T}): T?
    return arr[1]
end

local n = first({1, 2, 3})      -- integer?
local s = first({"a", "b"})     -- string?

type Box<T> = {value: T}
local box: Box<string> = {value = "hello"}

Flow Narrowing

The checker tracks types through control flow. After a nil check, the type is narrowed:

local function process(data: {value: number}?)
    if not data then return end
    print(data.value)  -- data is not nil here
end

Works with union types too:

type Exit = {kind: "exit", code: number}
type Message = {kind: "message", text: string}
type Event = Exit | Message

local function handle(e: Event)
    if e.kind == "exit" then
        print(e.code)  -- e is Exit
    else
        print(e.text)  -- e is Message
    end
end

Effects

Functions track side effects. The stdlib is annotated with what each function does — mutations, errors, I/O. This lets the checker understand code like:

assert(x ~= nil)
print(x.field)  -- x narrowed after assert

Running the VM

L := lua.NewState()
defer L.Close()

if err := L.DoString(`print("hello")`); err != nil {
    panic(err)
}

Error Metadata

WrapError and WrapErrorWithLua preserve metadata from wrapped *lua.Error values. For non-*lua.Error chains (for example errors from another package), register a process-wide metadata extractor once:

import (
    "errors"

    lua "github.com/wippyai/go-lua"
)

func init() {
    lua.ConfigureErrorMetadataExtractor(func(err error) *lua.ErrorMetadata {
        for e := err; e != nil; e = errors.Unwrap(e) {
            kindProvider, hasKind := e.(interface{ ErrorKind() string })
            retryProvider, hasRetry := e.(interface{ ErrorRetryable() (bool, bool) })
            detailsProvider, hasDetails := e.(interface{ ErrorDetails() map[string]any })
            if !hasKind && !hasRetry && !hasDetails {
                continue
            }

            meta := &lua.ErrorMetadata{}
            if hasKind {
                meta.Kind = lua.Kind(kindProvider.ErrorKind())
            }
            if hasRetry {
                if b, ok := retryProvider.ErrorRetryable(); ok {
                    v := b
                    meta.Retryable = &v
                }
            }
            if hasDetails {
                meta.Details = detailsProvider.ErrorDetails()
            }
            return meta
        }
        return nil
    })
}

ConfigureErrorMetadataExtractor is one-time (subsequent calls are ignored). For one-off calls, use WrapErrorWithMetadata(err, context, extractor) instead of changing global process state.

Type Checking

import (
    "github.com/ponyruntime/go-lua/compiler/parse"
    "github.com/ponyruntime/go-lua/types"
)

chunk, _ := parse.Parse(reader, "script.lua")
for _, d := range types.CheckChunk(chunk, types.WithStdlib()) {
    fmt.Printf("%s:%d: %s\n", d.Source, d.Line, d.Message)
}

License

MIT — see LICENSE. Based on gopher-lua by Yusuke Inuzuka.

Disclaimer

This project includes AI-generated and AI-assisted implementation work. The type system is currently stable, but it remains in a pre-convergence state.

Documentation ¶

Overview ¶

Package lua provides a VM and compiler for Lua in Go.

Index ¶

Constants ¶

View Source 
const (
	// BaseLibName is here for consistency; the base functions have no namespace/library.
	BaseLibName = ""
	// LoadLibName is here for consistency; the loading system has no namespace/library.
	LoadLibName = "package"
	// TabLibName is the name of the table Library.
	TabLibName = "table"
	// StringLibName is the name of the string Library.
	StringLibName = "string"
	// MathLibName is the name of the math Library.
	MathLibName = "math"
	// DebugLibName is the name of the debug Library.
	DebugLibName = "debug"
	// CoroutineLibName is the name of the coroutine Library.
	CoroutineLibName = "coroutine"
	// Utf8LibName is the name of the utf8 Library.
	Utf8LibName = "utf8"
	// ErrorsLibName is the name of the errors Library.
	ErrorsLibName = "errors"
)
View Source 
const (
	OP_MOVE     int = iota /*      A B     R(A) := R(B)                            */
	OP_MOVEN               /*      A B     R(A) := R(B); followed by R(C) MOVE ops */
	OP_LOADK               /*     A Bx    R(A) := Kst(Bx)                          */
	OP_LOADBOOL            /*  A B C   R(A) := (Bool)B; if (C) pc++                */
	OP_LOADNIL             /*   A B     R(A) := ... := R(B) := nil                 */
	OP_GETUPVAL            /*  A B     R(A) := UpValue[B]                          */

	OP_GETGLOBAL  /* A Bx    R(A) := Gbl[Kst(Bx)]                            */
	OP_GETTABLE   /*  A B C   R(A) := R(B)[RK(C)]                             */
	OP_GETTABLEKS /*  A B C   R(A) := R(B)[RK(C)] ; RK(C) is constant string */

	OP_SETGLOBAL  /* A Bx    Gbl[Kst(Bx)] := R(A)                            */
	OP_SETUPVAL   /*  A B     UpValue[B] := R(A)                              */
	OP_SETTABLE   /*  A B C   R(A)[RK(B)] := RK(C)                            */
	OP_SETTABLEKS /*  A B C   R(A)[RK(B)] := RK(C) ; RK(B) is constant string */

	OP_NEWTABLE /*  A B C   R(A) := {} (size = BC)                         */

	OP_SELF /*      A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]             */

	OP_ADD  /*       A B C   R(A) := RK(B) + RK(C)                           */
	OP_SUB  /*       A B C   R(A) := RK(B) - RK(C)                           */
	OP_MUL  /*       A B C   R(A) := RK(B) * RK(C)                           */
	OP_DIV  /*       A B C   R(A) := RK(B) / RK(C)                           */
	OP_MOD  /*       A B C   R(A) := RK(B) % RK(C)                           */
	OP_POW  /*       A B C   R(A) := RK(B) ^ RK(C)                           */
	OP_IDIV /*       A B C   R(A) := RK(B) // RK(C)                          */
	OP_BAND /*       A B C   R(A) := RK(B) & RK(C)                           */
	OP_BOR  /*       A B C   R(A) := RK(B) | RK(C)                           */
	OP_BXOR /*       A B C   R(A) := RK(B) ~ RK(C)                           */
	OP_SHL  /*       A B C   R(A) := RK(B) << RK(C)                          */
	OP_SHR  /*       A B C   R(A) := RK(B) >> RK(C)                          */
	OP_UNM  /*       A B     R(A) := -R(B)                                   */
	OP_BNOT /*       A B     R(A) := ~R(B)                                   */
	OP_NOT  /*       A B     R(A) := not R(B)                                */
	OP_LEN  /*       A B     R(A) := length of R(B)                          */

	OP_CONCAT /*    A B C   R(A) := R(B).. ... ..R(C)                       */

	OP_JMP /*       sBx     pc+=sBx                                 */

	OP_EQ /*        A B C   if ((RK(B) == RK(C)) ~= A) then pc++            */
	OP_LT /*        A B C   if ((RK(B) <  RK(C)) ~= A) then pc++            */
	OP_LE /*        A B C   if ((RK(B) <= RK(C)) ~= A) then pc++            */

	OP_TEST    /*      A C     if not (R(A) <=> C) then pc++                   */
	OP_TESTSET /*   A B C   if (R(B) <=> C) then R(A) := R(B) else pc++     */

	OP_CALL     /*      A B C   R(A) ... R(A+C-2) := R(A)(R(A+1) ... R(A+B-1)) */
	OP_TAILCALL /*  A B C   return R(A)(R(A+1) ... R(A+B-1))              */
	OP_RETURN   /*    A B     return R(A) ... R(A+B-2)      (see note)      */

	OP_FORLOOP /*   A sBx   R(A)+=R(A+2);
	     if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
	OP_FORPREP /*   A sBx   R(A)-=R(A+2); pc+=sBx                           */

	OP_TFORLOOP /*  A C     R(A+3) ... R(A+3+C) := R(A)(R(A+1) R(A+2));
	    if R(A+3) ~= nil then { pc++; R(A+2)=R(A+3); }  */
	OP_SETLIST /*   A B C   R(A)[(C-1)*FPF+i] := R(A+i) 1 <= i <= B        */

	OP_CLOSE   /*     A       close all variables in the stack up to (>=) R(A)*/
	OP_CLOSURE /*   A Bx    R(A) := closure(KPROTO[Bx] R(A) ... R(A+n))  */

	OP_VARARG /*     A B     R(A) R(A+1) ... R(A+B-1) = vararg            */

	OP_NOP /* NOP */

	OP_LOADTYPE /*  A Bx    R(A) := Type(Bx) (lookup by name)                 */
)
View Source 
const EnvironIndex = -10001
View Source 
const FramesPerSegment = 8

FramesPerSegment should be a power of 2 constant for performance reasons. It will allow the go compiler to change the divs and mods into bitshifts. Max is 256 due to current use of uint8 to count how many frames in a segment are used.

View Source 
const GlobalsIndex = -10002
View Source 
const LNumberBit = 64
View Source 
const MultRet = -1
View Source 
const PackageName = "GopherLua"
View Source 
const PackageVersion = "0.2 Wippy Edition"
View Source 
const RegistryIndex = -10000
View Source 
const VarArgIsVarArg uint8 = 2
View Source 
const Version = "Lua 5.3 - Wippy Modification"

Variables ¶

View Source 
var (
	LTypeNil     = &LType{inner: typ.Nil, name: "nil"}
	LTypeBoolean = &LType{inner: typ.Boolean, name: "boolean"}
	LTypeNumber  = &LType{inner: typ.Number, name: "number"}
	LTypeInteger = &LType{inner: typ.Integer, name: "integer"}
	LTypeString  = &LType{inner: typ.String, name: "string"}
	LTypeAny     = &LType{inner: typ.Any, name: "any"}
	LTypeUnknown = &LType{inner: typ.Unknown, name: "unknown"}
	LTypeNever   = &LType{inner: typ.Never, name: "never"}
)

Primitive type singletons - zero allocation for common types

View Source 
var CallStackSize = 128
View Source 
var DirSep string
View Source 
var ExecDir = "!"
View Source 
var FieldsPerFlush = 50
View Source 
var IgMark = "-"
View Source 
var LDir string // todo: drop it
View Source 
var LFalse = LBool(false)
View Source 
var LNil = LValue(&LNilType{})
View Source 
var LTrue = LBool(true)
View Source 
var MaxArrayIndex = 67108864
View Source 
var MaxTableGetLoop = 100
View Source 
var PathDefault string
View Source 
var PathEnvVar = "LUA_PATH"
View Source 
var PathMark = "?"
View Source 
var PathSep = ";"
View Source 
var RegistryGrowStep = 32
View Source 
var RegistryMaxSize = 256 * 256
View Source 
var RegistrySize = 256

Functions ¶

func ConfigureErrorMetadataExtractor ¶ added in v1.5.4 

func ConfigureErrorMetadataExtractor(extractor ErrorMetadataExtractor)

ConfigureErrorMetadataExtractor sets the process-wide error metadata extractor once. Subsequent calls are ignored.

func IsErrorKind ¶ 

func IsErrorKind(err error, kind Kind) bool

IsErrorKind checks if an error matches a specific kind.

func IsIntegerValue ¶ 

func IsIntegerValue(v LNumber) bool

IsIntegerValue checks if the runtime LNumber value has no fractional part.

func LVAsBool ¶ 

func LVAsBool(v LValue) bool

LVAsBool returns false if a given LValue is a nil or false otherwise true.

func LVAsString ¶ 

func LVAsString(v LValue) string

LVAsString returns string representation of a given LValue if the LValue is a string, number, or Error, otherwise an empty string.

func LVCanConvToString ¶ 

func LVCanConvToString(v LValue) bool

LVCanConvToString returns true if a given LValue is a string, number, or Error otherwise false.

func LVIsFalse ¶ 

func LVIsFalse(v LValue) bool

LVIsFalse returns true if a given LValue is a nil or false otherwise false.

func OpenBase ¶ 

func OpenBase(L *LState) int

func OpenCoroutine ¶ 

func OpenCoroutine(L *LState) int

func OpenDebug ¶ 

func OpenDebug(L *LState) int

func OpenErrors ¶ 

func OpenErrors(L *LState) int

OpenErrors registers the errors module and error metatable.

func OpenMath ¶ 

func OpenMath(L *LState) int

func OpenPackage ¶ 

func OpenPackage(L *LState) int

func OpenString ¶ 

func OpenString(L *LState) int

func OpenTable ¶ 

func OpenTable(L *LState) int

func OpenUtf8 ¶ 

func OpenUtf8(L *LState) int

func RegisterErrorMetatable ¶ 

func RegisterErrorMetatable(L *LState)

RegisterErrorMetatable registers the cached error metatable for this LState. This must be called once per LState to enable error methods like :kind().

func ReleaseSpawnRequest ¶ 

func ReleaseSpawnRequest(sr *SpawnRequest)

ReleaseSpawnRequest returns a SpawnRequest to the pool.

func SetErrorMetadataExtractor ¶ added in v1.5.4 

func SetErrorMetadataExtractor(extractor ErrorMetadataExtractor)

SetErrorMetadataExtractor overrides the process-wide extractor. This is primarily intended for tests.

func SetErrorMetatable ¶ 

func SetErrorMetatable(L *LState, e *Error)

SetErrorMetatable sets the error metatable on an Error value.

func TypeEquals ¶ 

func TypeEquals(a, b *LType) bool

TypeEquals checks structural equality of two types.

func TypeIsSubtype ¶ 

func TypeIsSubtype(a, b *LType) bool

TypeIsSubtype checks if a is a subtype of b.

func UpvalueIndex ¶ 

func UpvalueIndex(i int) int

Types ¶

type ApiError ¶ 

type ApiError struct {
	Type       ApiErrorType
	Object     LValue
	StackTrace string
	// Underlying error. This attribute is set only if the Type is ApiErrorFile or ApiErrorSyntax
	Cause error
}

func (*ApiError) Error ¶ 

func (e *ApiError) Error() string

func (*ApiError) String ¶ 

func (e *ApiError) String() string

type ApiErrorType ¶ 

type ApiErrorType int
const (
	ApiErrorSyntax ApiErrorType = iota
	ApiErrorFile
	ApiErrorRun
	ApiErrorError
	ApiErrorPanic
)

type CompileError ¶ 

type CompileError struct {
	Line    int
	Message string
	// contains filtered or unexported fields
}

func (*CompileError) Error ¶ 

func (e *CompileError) Error() string

func (*CompileError) String ¶ 

func (e *CompileError) String() string

type CompileOptions ¶ added in v1.5.2 

type CompileOptions struct {
	TypeInfo  []byte
	TypeNames map[string]struct{}
}

CompileOptions configures compile-time type resolution for type calls.

TypeInfo should contain the encoded manifest bytes. When provided, its type names are added to the compile-time type name set and stored on the proto. TypeNames can be used to supply additional compile-time type names directly.

type DbgCall ¶ 

type DbgCall struct {
	Name string
	Pc   int
}

type DbgLocalInfo ¶ 

type DbgLocalInfo struct {
	Name    string
	StartPc int
	EndPc   int
}

type Debug ¶ 

type Debug struct {
	Name            string
	What            string
	Source          string
	CurrentLine     int
	NUpvalues       int
	LineDefined     int
	LastLineDefined int
	// contains filtered or unexported fields
}

type Error ¶ 

type Error struct {
	Err      error       // Wrapped error (error chain)
	Message  string      // Error message
	LuaStack *StackTrace // Lua stack at wrap point

	Context string // Context description
	// contains filtered or unexported fields
}

Error is the unified error type for go-lua. It implements both error and LValue interfaces. Behaves like a string for concatenation and tostring().

func AsError ¶ 

func AsError(v LValue) (*Error, bool)

AsError extracts an Error from an LValue if possible.

func GetError ¶ 

func GetError(err error) *Error

GetError extracts a *Error from an error chain using errors.As. Returns nil if no *Error is found in the chain.

func NewError ¶ 

func NewError(message string) *Error

NewError creates a new error with the given message.

func NewErrorf ¶ 

func NewErrorf(format string, args ...any) *Error

NewErrorf creates a new error with formatted message.

func NewLuaError ¶ 

func NewLuaError(L *LState, message string) *Error

NewLuaError creates an Error and sets up its metatable.

func WrapError ¶ 

func WrapError(err error, context string) *Error

WrapError wraps an existing Go error with context.

func WrapErrorWithLua ¶ 

func WrapErrorWithLua(l *LState, err error, context string) *Error

WrapErrorWithLua wraps an error, captures Lua stack trace, and sets the error metatable.

func WrapErrorWithMetadata ¶ added in v1.5.4 

func WrapErrorWithMetadata(err error, context string, extractor ErrorMetadataExtractor) *Error

WrapErrorWithMetadata wraps an error with an explicit metadata extractor.

func (*Error) Details ¶ 

func (e *Error) Details() map[string]any

Details returns structured metadata about the error.

func (*Error) Error ¶ 

func (e *Error) Error() string

Error implements the error interface.

func (*Error) Kind ¶ 

func (e *Error) Kind() Kind

Kind returns the error category.

func (*Error) Retryable ¶ 

func (e *Error) Retryable() Ternary

Retryable returns whether the operation should be retried.

func (*Error) Stack ¶ 

func (e *Error) Stack() string

Stack returns a formatted stack trace including both Lua and Go stacks.

func (*Error) String ¶ 

func (e *Error) String() string

String implements LValue - returns the message for tostring() and concat.

func (*Error) Type ¶ 

func (e *Error) Type() LValueType

Type implements LValue - returns LTUserData.

func (*Error) Unwrap ¶ 

func (e *Error) Unwrap() error

Unwrap returns the underlying error for errors.Is/As support.

func (*Error) WithContext ¶ 

func (e *Error) WithContext(ctx string) *Error

WithContext adds context description.

func (*Error) WithDetails ¶ 

func (e *Error) WithDetails(d map[string]any) *Error

WithDetails sets structured metadata.

func (*Error) WithKind ¶ 

func (e *Error) WithKind(k Kind) *Error

WithKind sets the error category.

func (*Error) WithRetryable ¶ 

func (e *Error) WithRetryable(r bool) *Error

WithRetryable sets the retry status.

type ErrorMetadata ¶ added in v1.5.4 

type ErrorMetadata struct {
	Kind      Kind
	Retryable *bool
	Details   map[string]any
}

ErrorMetadata is portable metadata extracted from a Go error chain.

type ErrorMetadataExtractor ¶ added in v1.5.4 

type ErrorMetadataExtractor func(err error) *ErrorMetadata

ErrorMetadataExtractor extracts metadata from an error chain.

type FunctionProto ¶ 

type FunctionProto struct {
	SourceName         string
	LineDefined        int
	LastLineDefined    int
	NumUpvalues        uint8
	NumParameters      uint8
	IsVarArg           uint8
	NumUsedRegisters   uint8
	Code               []uint32
	Constants          []LValue
	FunctionPrototypes []*FunctionProto

	DbgSourcePositions []int
	DbgLocals          []*DbgLocalInfo
	DbgCalls           []DbgCall
	DbgUpvalues        []string

	// TypeInfo holds encoded type manifest for this module.
	// Use types/io.EncodeManifest/DecodeManifest to work with this data.
	// Stored on the root FunctionProto and propagated to nested functions.
	TypeInfo []byte
	// contains filtered or unexported fields
}

func Compile ¶ 

func Compile(chunk []ast.Stmt, name string) (proto *FunctionProto, err error)

func CompileReader ¶ 

func CompileReader(reader io.Reader, name string) (*FunctionProto, error)

CompileReader compiles Lua source from a reader to bytecode.

func CompileString ¶ 

func CompileString(source, name string) (*FunctionProto, error)

CompileString compiles Lua source code to bytecode without requiring an LState. The returned FunctionProto can be reused across multiple LStates.

func CompileWithOptions ¶ added in v1.5.2 

func CompileWithOptions(chunk []ast.Stmt, name string, opts CompileOptions) (proto *FunctionProto, err error)

CompileWithOptions compiles Lua source with compile-time type call resolution.

func (*FunctionProto) GetTypeInfo ¶ 

func (fp *FunctionProto) GetTypeInfo() []byte

GetTypeInfo returns the encoded type manifest bytes.

func (*FunctionProto) RebuildStringConstants ¶ 

func (fp *FunctionProto) RebuildStringConstants()

RebuildStringConstants rebuilds the stringConstants cache from Constants. This is needed after deserializing bytecode since stringConstants is not serialized. The stringConstants slice has the same length as Constants - each entry is either the string value (if Constants[i] is LString) or empty string (otherwise).

func (*FunctionProto) SetTypeInfo ¶ 

func (fp *FunctionProto) SetTypeInfo(data []byte)

SetTypeInfo sets the encoded type manifest bytes.

func (*FunctionProto) String ¶ 

func (fp *FunctionProto) String() string

type Global ¶ 

type Global struct {
	MainThread    *LState
	CurrentThread *LState
	Registry      *LTable
	Global        *LTable

	// Owner is the host process/context that owns this Lua VM.
	// Set by the host runtime for fast access from modules.
	Owner any
	// contains filtered or unexported fields
}

type Kind ¶ 

type Kind string

Kind categorizes errors semantically. 

const (
	Unknown          Kind = ""
	NotFound         Kind = "NotFound"
	AlreadyExists    Kind = "AlreadyExists"
	Invalid          Kind = "Invalid"
	PermissionDenied Kind = "PermissionDenied"
	Unavailable      Kind = "Unavailable"
	Internal         Kind = "Internal"
	Canceled         Kind = "Canceled"
	Conflict         Kind = "Conflict"
	Timeout          Kind = "Timeout"
	RateLimited      Kind = "RateLimited"
)

func GetErrorKind ¶ 

func GetErrorKind(err error) Kind

GetErrorKind extracts the kind from an error.

func (Kind) String ¶ 

func (k Kind) String() string

type LBool ¶ 

type LBool bool

func (LBool) Bool ¶ 

func (bl LBool) Bool() bool

Make LBool implement booler for validate package

func (LBool) String ¶ 

func (bl LBool) String() string

func (LBool) Type ¶ 

func (bl LBool) Type() LValueType

type LFunction ¶ 

type LFunction struct {
	IsG       bool
	Env       *LTable
	Proto     *FunctionProto
	GFunction LGFunction
	Upvalues  []*Upvalue
}

func (*LFunction) LocalName ¶ 

func (fn *LFunction) LocalName(regno, pc int) (string, bool)

func (*LFunction) String ¶ 

func (fn *LFunction) String() string

func (*LFunction) Type ¶ 

func (fn *LFunction) Type() LValueType

type LGContinuation ¶ 

type LGContinuation func(L *LState, ctx any, status ResumeState) int

LGContinuation is the type for Go function continuations after yield. ctx is user-defined context passed through yield, status is the resume result.

type LGFunction ¶ 

type LGFunction func(*LState) int

LGFunction is the Go function signature for Lua-callable functions.

type LGoFunc ¶ 

type LGoFunc LGFunction

LGoFunc is a stateless Go function that can be shared across all LStates. Unlike LFunction, it requires no per-state allocation and can be stored directly in tables or globals without wrapping.

Performance: LGoFunc avoids the LFunction allocation overhead and pointer indirection through Fn.GFunction. For modules that don't need upvalues or environments, using LGoFunc provides better performance.

TODO: Refactor all go-lua internal code to use LGoFunc natively: - Migrate internal libs (baselib, stringlib, mathlib, tablelib, etc.) to use LGoFunc - Simplify callFrame to primarily use GoFunc, remove Fn.IsG complexity - Update pushCallFrame, initCallFrame to assume GoFunc is the default - Remove legacy LFunction wrapping code and pinning state hacks - Update public API (SetGlobal, PreloadModule, etc.) to prefer LGoFunc This would eliminate the dual code paths in VM and simplify maintenance.

func (LGoFunc) String ¶ 

func (gf LGoFunc) String() string

func (LGoFunc) Type ¶ 

func (gf LGoFunc) Type() LValueType

type LInteger ¶ 

type LInteger int64

func (LInteger) Int64 ¶ 

func (i LInteger) Int64() int64

Make LInteger implement int64er for validate package

func (LInteger) String ¶ 

func (i LInteger) String() string

func (LInteger) Type ¶ 

func (i LInteger) Type() LValueType

type LNilType ¶ 

type LNilType struct{}

func (*LNilType) String ¶ 

func (nl *LNilType) String() string

func (*LNilType) Type ¶ 

func (nl *LNilType) Type() LValueType

type LNumber ¶ 

type LNumber float64

func LVAsNumber ¶ 

func LVAsNumber(v LValue) LNumber

LVAsNumber tries to convert a given LValue to a number.

func (LNumber) Float64 ¶ 

func (nm LNumber) Float64() float64

Make LNumber implement float64er for validate package

func (LNumber) Format ¶ 

func (nm LNumber) Format(f fmt.State, c rune)

Format implements the fmt.Formatter interface.

func (LNumber) String ¶ 

func (nm LNumber) String() string

func (LNumber) Type ¶ 

func (nm LNumber) Type() LValueType

type LState ¶ 

type LState struct {
	G       *Global
	Parent  *LState
	Env     *LTable
	Panic   func(*LState)
	Dead    bool
	Options Options
	// contains filtered or unexported fields
}

func NewState ¶ 

func NewState(opts ...Options) *LState

func (*LState) ArgError ¶ 

func (ls *LState) ArgError(n int, message string)

func (*LState) Call ¶ 

func (ls *LState) Call(nargs, nret int)

func (*LState) CallByParam ¶ 

func (ls *LState) CallByParam(cp P, args ...LValue) error

func (*LState) CallK ¶ 

func (ls *LState) CallK(nargs, nret int, cont LGContinuation, ctx any)

CallK calls a function with a continuation for yield support. If the called function yields, the continuation will be called on resume instead of returning to the caller. The continuation receives the LState, user context, and resume status.

func (*LState) CallMeta ¶ 

func (ls *LState) CallMeta(obj LValue, event string) LValue

func (*LState) CheckAny ¶ 

func (ls *LState) CheckAny(n int) LValue

func (*LState) CheckBool ¶ 

func (ls *LState) CheckBool(n int) bool

func (*LState) CheckFunction ¶ 

func (ls *LState) CheckFunction(n int) *LFunction

func (*LState) CheckInt ¶ 

func (ls *LState) CheckInt(n int) int

func (*LState) CheckInt64 ¶ 

func (ls *LState) CheckInt64(n int) int64

func (*LState) CheckNumber ¶ 

func (ls *LState) CheckNumber(n int) LNumber

func (*LState) CheckOption ¶ 

func (ls *LState) CheckOption(n int, options []string) int

func (*LState) CheckString ¶ 

func (ls *LState) CheckString(n int) string

func (*LState) CheckTable ¶ 

func (ls *LState) CheckTable(n int) *LTable

func (*LState) CheckThread ¶ 

func (ls *LState) CheckThread(n int) *LState

func (*LState) CheckType ¶ 

func (ls *LState) CheckType(n int, typ LValueType)

func (*LState) CheckTypes ¶ 

func (ls *LState) CheckTypes(n int, typs ...LValueType)

func (*LState) CheckUserData ¶ 

func (ls *LState) CheckUserData(n int) *LUserData

func (*LState) Close ¶ 

func (ls *LState) Close()

Close returns the state to pool if appropriate.

func (*LState) Concat ¶ 

func (ls *LState) Concat(values ...LValue) string

func (*LState) Context ¶ 

func (ls *LState) Context() context.Context

Context returns the LState's context. To change the context, use WithContext.

func (*LState) CreateTable ¶ 

func (ls *LState) CreateTable(acap, hcap int) *LTable

func (*LState) DoFile ¶ 

func (ls *LState) DoFile(path string) error

func (*LState) DoString ¶ 

func (ls *LState) DoString(source string) error

func (*LState) Equal ¶ 

func (ls *LState) Equal(lhs, rhs LValue) bool

func (*LState) Error ¶ 

func (ls *LState) Error(lv LValue, level int)

Error is equivalent to lua_error( http://www.lua.org/manual/5.1/manual.html#lua_error ).

func (*LState) FindTable ¶ 

func (ls *LState) FindTable(obj *LTable, n string, size int) LValue

func (*LState) ForEach ¶ 

func (ls *LState) ForEach(tb *LTable, cb func(LValue, LValue))

func (*LState) GPCall ¶ 

func (ls *LState) GPCall(fn LGFunction, data LValue) error

func (*LState) Get ¶ 

func (ls *LState) Get(idx int) LValue

func (*LState) GetField ¶ 

func (ls *LState) GetField(obj LValue, skey string) LValue

func (*LState) GetGlobal ¶ 

func (ls *LState) GetGlobal(name string) LValue

func (*LState) GetInfo ¶ 

func (ls *LState) GetInfo(what string, dbg *Debug, fn LValue) (LValue, error)

func (*LState) GetLocal ¶ 

func (ls *LState) GetLocal(dbg *Debug, no int) (string, LValue)

func (*LState) GetMetaField ¶ 

func (ls *LState) GetMetaField(obj LValue, event string) LValue

func (*LState) GetMetatable ¶ 

func (ls *LState) GetMetatable(obj LValue) LValue

func (*LState) GetStack ¶ 

func (ls *LState) GetStack(level int) (*Debug, bool)

func (*LState) GetTable ¶ 

func (ls *LState) GetTable(obj LValue, key LValue) LValue

func (*LState) GetTop ¶ 

func (ls *LState) GetTop() int

func (*LState) GetTypeMetatable ¶ 

func (ls *LState) GetTypeMetatable(typ string) LValue

func (*LState) GetUpvalue ¶ 

func (ls *LState) GetUpvalue(fn *LFunction, no int) (string, LValue)

func (*LState) Insert ¶ 

func (ls *LState) Insert(value LValue, index int)

func (*LState) IsClosed ¶ 

func (ls *LState) IsClosed() bool

func (*LState) LessThan ¶ 

func (ls *LState) LessThan(lhs, rhs LValue) bool

func (*LState) Load ¶ 

func (ls *LState) Load(reader io.Reader, name string) (*LFunction, error)

func (*LState) LoadFile ¶ 

func (ls *LState) LoadFile(path string) (*LFunction, error)

func (*LState) LoadProto ¶ 

func (ls *LState) LoadProto(proto *FunctionProto) *LFunction

LoadProto creates an LFunction from a precompiled FunctionProto. This is much faster than Load() since it skips parsing and compilation.

func (*LState) LoadString ¶ 

func (ls *LState) LoadString(source string) (*LFunction, error)

func (*LState) NewClosure ¶ 

func (ls *LState) NewClosure(fn LGFunction, upvalues ...LValue) *LFunction

func (*LState) NewFunction ¶ 

func (ls *LState) NewFunction(fn LGFunction) *LFunction

func (*LState) NewFunctionFromProto ¶ 

func (ls *LState) NewFunctionFromProto(proto *FunctionProto) *LFunction

func (*LState) NewTable ¶ 

func (ls *LState) NewTable() *LTable

func (*LState) NewThread ¶ 

func (ls *LState) NewThread() (*LState, context.CancelFunc)

NewThread creates a new coroutine thread with a cancellable context. Returns the thread and a cancel function that should be called when done.

func (*LState) NewThreadWithContext ¶ 

func (ls *LState) NewThreadWithContext(ctx context.Context) *LState

NewThreadWithContext returns a new LState with the given context. Pass nil for no context (faster execution without cancellation checks).

func (*LState) NewTypeMetatable ¶ 

func (ls *LState) NewTypeMetatable(typ string) *LTable

func (*LState) NewUserData ¶ 

func (ls *LState) NewUserData() *LUserData

func (*LState) Next ¶ 

func (ls *LState) Next(tb *LTable, key LValue) (LValue, LValue)

func (*LState) ObjLen ¶ 

func (ls *LState) ObjLen(v1 LValue) int

func (*LState) OpenLibs ¶ 

func (ls *LState) OpenLibs()

OpenLibs loads the built-in libraries. It is equivalent to running OpenLoad, then OpenBase, then iterating over the other OpenXXX functions in any order.

func (*LState) OptBool ¶ 

func (ls *LState) OptBool(n int, d bool) bool

func (*LState) OptFunction ¶ 

func (ls *LState) OptFunction(n int, d *LFunction) *LFunction

func (*LState) OptInt ¶ 

func (ls *LState) OptInt(n int, d int) int

func (*LState) OptInt64 ¶ 

func (ls *LState) OptInt64(n int, d int64) int64

func (*LState) OptNumber ¶ 

func (ls *LState) OptNumber(n int, d LNumber) LNumber

func (*LState) OptString ¶ 

func (ls *LState) OptString(n int, d string) string

func (*LState) OptTable ¶ 

func (ls *LState) OptTable(n int, d *LTable) *LTable

func (*LState) OptUserData ¶ 

func (ls *LState) OptUserData(n int, d *LUserData) *LUserData

func (*LState) PCall ¶ 

func (ls *LState) PCall(nargs, nret int, errfunc *LFunction) (err error)

func (*LState) Pop ¶ 

func (ls *LState) Pop(n int)

func (*LState) PreloadModule ¶ 

func (ls *LState) PreloadModule(name string, loader LGFunction)

PreloadModule sets a module loader to the package.preload table.

func (*LState) Push ¶ 

func (ls *LState) Push(value LValue)

func (*LState) RaiseError ¶ 

func (ls *LState) RaiseError(format string, args ...any)

RaiseError is equivalent to luaL_error( http://www.lua.org/manual/5.1/manual.html#luaL_error ).

func (*LState) RawEqual ¶ 

func (ls *LState) RawEqual(lhs, rhs LValue) bool

func (*LState) RawGet ¶ 

func (ls *LState) RawGet(tb *LTable, key LValue) LValue

func (*LState) RawGetInt ¶ 

func (ls *LState) RawGetInt(tb *LTable, key int) LValue

func (*LState) RawSet ¶ 

func (ls *LState) RawSet(tb *LTable, key LValue, value LValue)

func (*LState) RawSetInt ¶ 

func (ls *LState) RawSetInt(tb *LTable, key int, value LValue)

func (*LState) Register ¶ 

func (ls *LState) Register(name string, fn LGFunction)

func (*LState) RegisterGoModule ¶ 

func (ls *LState) RegisterGoModule(name string, funcs map[string]LGoFunc) LValue

RegisterGoModule registers a module using LGoFunc functions. LGoFunc values are stored directly without wrapping.

func (*LState) RegisterModule ¶ 

func (ls *LState) RegisterModule(name string, funcs map[string]LGFunction) LValue

func (*LState) Remove ¶ 

func (ls *LState) Remove(index int)

func (*LState) RemoveContext ¶ 

func (ls *LState) RemoveContext() context.Context

RemoveContext removes the context associated with this LState and returns this context.

func (*LState) Replace ¶ 

func (ls *LState) Replace(idx int, value LValue)

func (*LState) Resume ¶ 

func (ls *LState) Resume(th *LState, fn *LFunction, args ...LValue) (ResumeState, []LValue, error)

func (*LState) ResumeInto ¶ 

func (ls *LState) ResumeInto(th *LState, fn *LFunction, retBuf []LValue, args ...LValue) (ResumeState, []LValue, error)

ResumeInto is like Resume but uses a pre-allocated buffer for return values. This avoids allocations in the hot path.

func (*LState) SetContext ¶ 

func (ls *LState) SetContext(ctx context.Context)

SetContext set a context ctx to this LState. The provided ctx must be non-nil.

func (*LState) SetField ¶ 

func (ls *LState) SetField(obj LValue, key string, value LValue)

func (*LState) SetFuncs ¶ 

func (ls *LState) SetFuncs(tb *LTable, funcs map[string]LGFunction, upvalues ...LValue) *LTable

func (*LState) SetGlobal ¶ 

func (ls *LState) SetGlobal(name string, value LValue)

func (*LState) SetGoFuncs ¶ 

func (ls *LState) SetGoFuncs(tb *LTable, funcs map[string]LGoFunc) *LTable

SetGoFuncs sets LGoFunc values directly on the table.

func (*LState) SetLocal ¶ 

func (ls *LState) SetLocal(dbg *Debug, no int, lv LValue) string

func (*LState) SetMetatable ¶ 

func (ls *LState) SetMetatable(obj LValue, mt LValue)

func (*LState) SetTable ¶ 

func (ls *LState) SetTable(obj LValue, key LValue, value LValue)

func (*LState) SetTop ¶ 

func (ls *LState) SetTop(idx int)

func (*LState) SetUpvalue ¶ 

func (ls *LState) SetUpvalue(fn *LFunction, no int, lv LValue) string

func (*LState) Status ¶ 

func (ls *LState) Status(th *LState) string

func (*LState) String ¶ 

func (ls *LState) String() string

func (*LState) ToBool ¶ 

func (ls *LState) ToBool(n int) bool

func (*LState) ToFunction ¶ 

func (ls *LState) ToFunction(n int) *LFunction

func (*LState) ToInt ¶ 

func (ls *LState) ToInt(n int) int

func (*LState) ToInt64 ¶ 

func (ls *LState) ToInt64(n int) int64

func (*LState) ToNumber ¶ 

func (ls *LState) ToNumber(n int) LNumber

func (*LState) ToString ¶ 

func (ls *LState) ToString(n int) string

func (*LState) ToStringMeta ¶ 

func (ls *LState) ToStringMeta(lv LValue) LValue

ToStringMeta returns string representation of given LValue. This method calls the `__tostring` meta method if defined.

func (*LState) ToTable ¶ 

func (ls *LState) ToTable(n int) *LTable

func (*LState) ToThread ¶ 

func (ls *LState) ToThread(n int) *LState

func (*LState) ToUserData ¶ 

func (ls *LState) ToUserData(n int) *LUserData

func (*LState) Type ¶ 

func (ls *LState) Type() LValueType

func (*LState) TypeError ¶ 

func (ls *LState) TypeError(n int, typ LValueType)

func (*LState) Where ¶ 

func (ls *LState) Where(level int) string

func (*LState) XMoveTo ¶ 

func (ls *LState) XMoveTo(other *LState, n int)

func (*LState) Yield ¶ 

func (ls *LState) Yield(values ...LValue) int

type LString ¶ 

type LString string

func (LString) Format ¶ 

func (st LString) Format(f fmt.State, c rune)

Format implements the fmt.Formatter interface.

func (LString) String ¶ 

func (st LString) String() string

func (LString) Type ¶ 

func (st LString) Type() LValueType

type LTable ¶ 

type LTable struct {
	Metatable LValue
	Immutable bool

	Array   []LValue
	Dict    map[LValue]LValue
	Strdict map[string]LValue
	Keys    []LValue
	K2i     map[LValue]int
}

func CreateTable ¶ 

func CreateTable(acap, hcap int) *LTable

func (*LTable) Append ¶ 

func (tb *LTable) Append(value LValue) bool

Append appends a given LValue to this LTable.

func (*LTable) ForEach ¶ 

func (tb *LTable) ForEach(cb func(LValue, LValue))

ForEach iterates over this table of elements, yielding each in turn to a given function.

func (*LTable) Insert ¶ 

func (tb *LTable) Insert(i int, value LValue) bool

Insert inserts a given LValue at position `i` in this table.

func (*LTable) Len ¶ 

func (tb *LTable) Len() int

Len returns length of this LTable without using __len.

func (*LTable) MaxN ¶ 

func (tb *LTable) MaxN() int

MaxN returns a maximum number key that nil value does not exist before it.

func (*LTable) Next ¶ 

func (tb *LTable) Next(key LValue) (LValue, LValue)

Next is equivalent to lua_next ( http://www.lua.org/manual/5.1/manual.html#lua_next ).

func (*LTable) RawGet ¶ 

func (tb *LTable) RawGet(key LValue) LValue

RawGet returns an LValue associated with a given key without __index metamethod.

func (*LTable) RawGetH ¶ 

func (tb *LTable) RawGetH(key LValue) LValue

RawGetH returns an LValue associated with a given key without __index metamethod.

func (*LTable) RawGetInt ¶ 

func (tb *LTable) RawGetInt(key int) LValue

RawGetInt returns an LValue at position `key` without __index metamethod.

func (*LTable) RawGetString ¶ 

func (tb *LTable) RawGetString(key string) LValue

RawGetString returns an LValue associated with a given key without __index metamethod.

func (*LTable) RawSet ¶ 

func (tb *LTable) RawSet(key LValue, value LValue) bool

RawSet sets a given LValue to a given index without the __newindex metamethod. It is recommended to use `RawSetString` or `RawSetInt` for performance if you already know the given LValue is a string or number.

func (*LTable) RawSetH ¶ 

func (tb *LTable) RawSetH(key LValue, value LValue) bool

RawSetH sets a given LValue to a given index without the __newindex metamethod. OPTIMIZED: No longer creates Keys/K2i or Dict until actually needed

func (*LTable) RawSetInt ¶ 

func (tb *LTable) RawSetInt(key int, value LValue) bool

RawSetInt sets a given LValue at a position `key` without the __newindex metamethod.

func (*LTable) RawSetString ¶ 

func (tb *LTable) RawSetString(key string, value LValue) bool

RawSetString sets a given LValue to a given string index without the __newindex metamethod.

func (*LTable) Remove ¶ 

func (tb *LTable) Remove(pos int) (LValue, bool)

Remove removes from this table the element at a given position.

func (*LTable) String ¶ 

func (tb *LTable) String() string

func (*LTable) Type ¶ 

func (tb *LTable) Type() LValueType

type LType ¶ 

type LType struct {
	// contains filtered or unexported fields
}

LType is a runtime type value that can be used in Lua code. It wraps a typ.Type and implements the LValue interface. Types are first-class values: callable for validation, comparable, and support reflection via direct VM dispatch (no metatables).

func NewLType ¶ 

func NewLType(t typ.Type) *LType

NewLType creates a new LType wrapping the given type.

func NewNamedLType ¶ 

func NewNamedLType(t typ.Type, name string) *LType

NewNamedLType creates a new named LType.

func (*LType) GoString ¶ 

func (lt *LType) GoString() string

Debug helper

func (*LType) Inner ¶ 

func (lt *LType) Inner() typ.Type

Inner returns the underlying typ.Type.

func (*LType) KindString ¶ 

func (lt *LType) KindString() string

KindString returns a string representation of the type's kind.

func (*LType) Name ¶ 

func (lt *LType) Name() string

Name returns the type name, or empty string for anonymous types.

func (*LType) String ¶ 

func (lt *LType) String() string

func (*LType) Type ¶ 

func (lt *LType) Type() LValueType

func (*LType) Validate ¶ 

func (lt *LType) Validate(L *LState, val LValue) bool

Validate checks if a value matches this type. Returns true if valid, false otherwise.

type LUserData ¶ 

type LUserData struct {
	Value     interface{}
	Metatable LValue
}

func (*LUserData) String ¶ 

func (ud *LUserData) String() string

func (*LUserData) Type ¶ 

func (ud *LUserData) Type() LValueType

type LValue ¶ 

type LValue interface {
	String() string
	Type() LValueType
}

type LValueType ¶ 

type LValueType int
const (
	LTNil LValueType = iota
	LTBool
	LTNumber
	LTInteger
	LTString
	LTFunction
	LTUserData
	LTThread
	LTTable
	LTChannel
	LTType
)

func (LValueType) String ¶ 

func (vt LValueType) String() string

type Options ¶ 

type Options struct {
	// Call stack size. This defaults to `lua.CallStackSize`.
	CallStackSize int
	// Data stack size. This defaults to `lua.RegistrySize`.
	RegistrySize int
	// Allow the registry to grow from the registry size specified up to a value of RegistryMaxSize. A value of 0
	// indicates no growth is permitted. The registry will not shrink again after any growth.
	RegistryMaxSize int
	// If growth is enabled, step up by an additional `RegistryGrowStep` each time to avoid having to resize too often.
	// This defaults to `lua.RegistryGrowStep`
	RegistryGrowStep int
	// Controls whether or not libraries are opened by default
	SkipOpenLibs bool
	// Tells whether a Go stacktrace should be included in a Lua stacktrace when panics occur.
	IncludeGoStackTrace bool
	// If `MinimizeStackMemory` is set, the call stack will be automatically grown or shrank up to a limit of
	// `CallStackSize` in order to minimize memory usage. This does incur a slight performance penalty.
	MinimizeStackMemory bool
}

Options is a configuration that is used to create a new LState.

type P ¶ 

type P struct {
	Fn      LValue
	NRet    int
	Protect bool
	Handler *LFunction
}

type ResumeState ¶ 

type ResumeState int
const (
	ResumeOK ResumeState = iota
	ResumeYield
	ResumeError
)

type SpawnRequest ¶ 

type SpawnRequest struct {
	Fn *LFunction
}

SpawnRequest is yielded by coroutine.spawn to signal the scheduler

func (*SpawnRequest) String ¶ 

func (s *SpawnRequest) String() string

func (*SpawnRequest) Type ¶ 

func (s *SpawnRequest) Type() LValueType

type StackFrame ¶ 

type StackFrame struct {
	Level       int
	Source      string
	CurrentLine int
	Name        string
	FuncType    string
}

StackFrame represents a single frame in the Lua stack (for error reporting).

func (StackFrame) String ¶ 

func (sf StackFrame) String() string

type StackTrace ¶ 

type StackTrace struct {
	ThreadID string
	Frames   []StackFrame
}

StackTrace represents a Lua stack trace.

func (StackTrace) String ¶ 

func (st StackTrace) String() string

type Ternary ¶ 

type Ternary int8

Ternary represents three-state logic for composable error handling. 

const (
	TernaryUnknown Ternary = 0
	TernaryTrue    Ternary = 1
	TernaryFalse   Ternary = 2
)

func (Ternary) Bool ¶ 

func (t Ternary) Bool() bool

func (Ternary) String ¶ 

func (t Ternary) String() string

type Upvalue ¶ 

type Upvalue struct {
	// contains filtered or unexported fields
}

func (*Upvalue) Close ¶ 

func (uv *Upvalue) Close()

func (*Upvalue) IsClosed ¶ 

func (uv *Upvalue) IsClosed() bool

func (*Upvalue) SetValue ¶ 

func (uv *Upvalue) SetValue(value LValue)

func (*Upvalue) Value ¶ 

func (uv *Upvalue) Value() LValue

type ValidationContext ¶ 

type ValidationContext struct {
	// contains filtered or unexported fields
}

ValidationContext wraps validate.Registry for LValue validation.

func DefaultValidationContext ¶ 

func DefaultValidationContext() *ValidationContext

DefaultValidationContext returns context with built-in validators.

func NewValidationContext ¶ 

func NewValidationContext() *ValidationContext

NewValidationContext creates empty context.

func (*ValidationContext) RegisterValidator ¶ 

func (vc *ValidationContext) RegisterValidator(name string, fn ValidatorFunc)

RegisterValidator adds a validator that works with LValue.

func (*ValidationContext) Validate ¶ 

func (vc *ValidationContext) Validate(val LValue, lt *LType) []*validate.Error

Validate checks value against type with annotations. Uses zero-alloc path building - paths only built on error.

type ValidatorFunc ¶ 

type ValidatorFunc func(val LValue, arg any) *validate.Error

ValidatorFunc validates an LValue against an annotation argument.

Source Files ¶

View all Source files

Directories ¶

Path Synopsis
compiler
ast
Package ast defines the abstract syntax tree for Lua source code.
 Package ast defines the abstract syntax tree for Lua source code.
bind
Package bind implements name resolution and symbol binding for Lua AST nodes.
 Package bind implements name resolution and symbol binding for Lua AST nodes.
bytecode
Package bytecode provides serialization and deserialization of compiled Lua bytecode.
 Package bytecode provides serialization and deserialization of compiled Lua bytecode.
cfg
Package cfg constructs control flow graphs from Lua AST nodes.
 Package cfg constructs control flow graphs from Lua AST nodes.
cfg/analysis
Package analysis provides pure graph analysis algorithms for CFGs.
 Package analysis provides pure graph analysis algorithms for CFGs.
cfg/extraction
Package extraction provides pure AST extraction functions for CFG construction.
 Package extraction provides pure AST extraction functions for CFG construction.
check
Package check implements a multi-phase, fixpoint-iterative type checking system for Lua.
 Package check implements a multi-phase, fixpoint-iterative type checking system for Lua.
check/api
Package api defines interfaces and types for the Lua type checker.
 Package api defines interfaces and types for the Lua type checker.
check/callsite
check/effects
Package effectops provides operations for function effect propagation.
 Package effectops provides operations for function effect propagation.
check/erreffect
check/flowbuild
Package flowbuild implements flow constraint extraction from control flow graphs.
 Package flowbuild implements flow constraint extraction from control flow graphs.
check/flowbuild/assign
Package assign provides flow-sensitive assignment analysis for the type checker.
 Package assign provides flow-sensitive assignment analysis for the type checker.
check/flowbuild/cond
Package cond implements condition constraint extraction for the flow type system.
 Package cond implements condition constraint extraction for the flow type system.
check/flowbuild/constprop
Package constprop performs constant propagation for flow analysis.
 Package constprop performs constant propagation for flow analysis.
check/flowbuild/core
Package base provides shared context types for flowbuild operations.
 Package base provides shared context types for flowbuild operations.
check/flowbuild/decl
Package decl extracts type declarations from function parameters and locals.
 Package decl extracts type declarations from function parameters and locals.
check/flowbuild/guard
Package guard extracts type guard conditions from control flow branches.
 Package guard extracts type guard conditions from control flow branches.
check/flowbuild/keyscoll
Package keyscoll collects table keys from expressions for type inference.
 Package keyscoll collects table keys from expressions for type inference.
check/flowbuild/literal
Package literal handles literal expression type synthesis for flow analysis.
 Package literal handles literal expression type synthesis for flow analysis.
check/flowbuild/mutator
Package mutator extracts container mutation operations from call sites.
 Package mutator extracts container mutation operations from call sites.
check/flowbuild/numconst
Package numconst handles numeric constant analysis for type inference.
 Package numconst handles numeric constant analysis for type inference.
check/flowbuild/path
Package path constructs constraint paths from AST expressions.
 Package path constructs constraint paths from AST expressions.
check/flowbuild/predicate
Package predicate builds type predicates from comparison expressions.
 Package predicate builds type predicates from comparison expressions.
check/flowbuild/resolve
Package resolve provides symbol and type resolution utilities for flow constraint extraction.
 Package resolve provides symbol and type resolution utilities for flow constraint extraction.
check/flowbuild/returns
Package returns extracts return type information from function bodies.
 Package returns extracts return type information from function bodies.
check/flowbuild/sibling
Package sibling handles sibling function analysis in nested scopes.
 Package sibling handles sibling function analysis in nested scopes.
check/flowbuild/tblutil
Package tblutil provides utilities for table type analysis.
 Package tblutil provides utilities for table type analysis.
check/hooks
assign_check.go implements assignment type validation for the type checker.
 assign_check.go implements assignment type validation for the type checker.
check/infer/captured
Package captured computes captured variable types for nested functions.
 Package captured computes captured variable types for nested functions.
check/infer/interproc
Package interproc handles interprocedural analysis after flow solving.
 Package interproc handles interprocedural analysis after flow solving.
check/infer/nested
Package nestedinfer processes nested function definitions during type analysis.
 Package nestedinfer processes nested function definitions during type analysis.
check/infer/paramhints
Package paramhints infers parameter types from call site arguments.
 Package paramhints infers parameter types from call site arguments.
check/infer/return
Package infer infers function return types from body analysis.
 Package infer infers function return types from body analysis.
check/modules
Package modules handles module export type computation.
 Package modules handles module export type computation.
check/nested
Package nested handles nested function analysis coordination.
 Package nested handles nested function analysis coordination.
check/phase
Package phase implements individual analysis phases for type checking.
 Package phase implements individual analysis phases for type checking.
check/pipeline
This package handles post-analysis diagnostic operations:
 This package handles post-analysis diagnostic operations:
check/returns
Package returns provides interprocedural return type analysis.
 Package returns provides interprocedural return type analysis.
check/scope
Package scope provides lexical scope state for type checking.
 Package scope provides lexical scope state for type checking.
check/siblings
Package siblings manages sibling function type coordination.
 Package siblings manages sibling function type coordination.
check/store
Package store provides session state management for type checking.
 Package store provides session state management for type checking.
check/synth
Package synth implements type synthesis for Lua expressions.
 Package synth implements type synthesis for Lua expressions.
check/synth/intercept
Package intercept handles special-case type synthesis interceptions.
 Package intercept handles special-case type synthesis interceptions.
check/synth/ops
Package ops implements type synthesis operations for the type checker.
 Package ops implements type synthesis operations for the type checker.
check/synth/phase/core
Package shared provides shared utilities for synthesis phases.
 Package shared provides shared utilities for synthesis phases.
check/synth/phase/extract
Package extract handles expression extraction from CFG for synthesis.
 Package extract handles expression extraction from CFG for synthesis.
check/synth/phase/resolve
Package resolve performs final type resolution after synthesis.
 Package resolve performs final type resolution after synthesis.
check/synth/transform
Package transform provides type transformation operations.
 Package transform provides type transformation operations.
check/tests/testutil
parse
Package parse implements lexical analysis and parsing for Lua source code.
 Package parse implements lexical analysis and parsing for Lua source code.
pathseg
stdlib
Package stdlib provides type definitions for Lua's standard library.
 Package stdlib provides type definitions for Lua's standard library.
Package internal provides pure data structures for the type system.
 Package internal provides pure data structures for the type system.
lsp
Package lsp provides LSP query operations for the type system.
 Package lsp provides LSP query operations for the type system.
completion
Package completion provides code completion for LSP.
 Package completion provides code completion for LSP.
edit
Package edit provides text editing utilities for the language server.
 Package edit provides text editing utilities for the language server.
index
Package index provides per-function indexing for type checking results.
 Package index provides per-function indexing for type checking results.
refactor
Package refactor provides code refactoring operations for the language server.
 Package refactor provides code refactoring operations for the language server.
semantic
Package semantic provides semantic token analysis for syntax highlighting.
 Package semantic provides semantic token analysis for syntax highlighting.
signature
Package signature provides function signature help for the language server.
 Package signature provides function signature help for the language server.
Package pm provides Lua pattern matching functions for Go.
 Package pm provides Lua pattern matching functions for Go.
types
cfg
Package cfg provides control flow graph representation for dataflow analysis.
 Package cfg provides control flow graph representation for dataflow analysis.
constraint
Package constraint provides multi-path narrowing constraints for type refinement.
 Package constraint provides multi-path narrowing constraints for type refinement.
constraint/theory
Package theory provides modular constraint solving theories for SMT-style reasoning.
 Package theory provides modular constraint solving theories for SMT-style reasoning.
contract
Package contract provides function behavior specifications using Hoare-style contracts.
 Package contract provides function behavior specifications using Hoare-style contracts.
db
Package db provides a Salsa-style incremental computation database for efficient re-analysis when source files change.
 Package db provides a Salsa-style incremental computation database for efficient re-analysis when source files change.
diag
Package diag provides diagnostic reporting for the type checker.
 Package diag provides diagnostic reporting for the type checker.
effect
Effect label codecs for serialization and deserialization.
 Effect label codecs for serialization and deserialization.
flow
Package flow provides control flow type propagation and flow-sensitive analysis.
 Package flow provides control flow type propagation and flow-sensitive analysis.
flow/domain
Package domain provides abstract domain interfaces for constraint solving.
 Package domain provides abstract domain interfaces for constraint solving.
flow/join
Package join provides type joining operations for phi node merging.
 Package join provides type joining operations for phi node merging.
flow/numeric
domain.go implements the numeric subdomain for the flow solver's ProductDomain.
 domain.go implements the numeric subdomain for the flow solver's ProductDomain.
flow/pathkey
key.go provides path key construction and manipulation utilities.
 key.go provides path key construction and manipulation utilities.
flow/propagate
Package propagate computes type constraints at CFG points via forward propagation.
 Package propagate computes type constraints at CFG points via forward propagation.
io
Package io provides binary serialization and deserialization for Lua types.
 Package io provides binary serialization and deserialization for Lua types.
kind
Package kind defines type kind enumeration for efficient type discrimination.
 Package kind defines type kind enumeration for efficient type discrimination.
narrow
Package narrow provides type narrowing operations for control flow refinement.
 Package narrow provides type narrowing operations for control flow refinement.
numparse
query/core
Package core provides pure type inspection, query, and lookup operations for the Lua type system.
 Package core provides pure type inspection, query, and lookup operations for the Lua type system.
subtype
Package subtype provides subtype checking with seen-map cycle detection.
 Package subtype provides subtype checking with seen-map cycle detection.
typ
Package typ defines the core Type interface and type implementations.
 Package typ defines the core Type interface and type implementations.
typ/join
Package join provides type join operations for control flow merging.
 Package join provides type join operations for control flow merging.
typ/subst
Package subst provides type substitution operations for generics.
 Package subst provides type substitution operations for generics.
typ/union
Package union provides union type analysis operations.
 Package union provides union type analysis operations.
typ/unwrap
Package unwrap provides type unwrapping, extraction, and predicate operations.
 Package unwrap provides type unwrapping, extraction, and predicate operations.
Package validate provides validation for LValue types.
 Package validate provides validation for LValue types.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.