compiler

type CapturedOutput struct {
	Output   string
	ExitCode int
}

type CompileResult struct {
	GoSource   string
	Program    *ast.Program
	SourceFile string         // original source filename
	Sandbox    *SandboxConfig // sandbox config (nil = no sandbox)
	// GoModuleRequires maps Go module paths to local cache directories
	// for Go modules discovered via require. Used by go.mod generation.
	GoModuleRequires map[string]string
}

type Compiler struct {
	// BaseDir is the directory of the main source file (for resolving requires).
	BaseDir string
	// TestMode enables test harness generation (rats blocks are included).
	// When false (default), rats blocks are silently skipped during codegen.
	TestMode bool
	// ModuleDir overrides the default module cache directory (~/.rugo/modules).
	// Used for testing. When empty, the default is used.
	ModuleDir string
	// Frozen errors if the lock file is stale or a new dependency is resolved.
	Frozen bool
	// Sandbox, when non-nil, overrides any sandbox directive in the script.
	// Populated by CLI flags (--sandbox --ro, --rw, etc.).
	Sandbox *SandboxConfig
	// Resolver overrides the default remote resolver. When set, the compiler
	// uses this resolver instead of creating one. Used by mod tidy to share
	// a single resolver across multiple compilations.
	Resolver *remote.Resolver
	// contains filtered or unexported fields
}

type FuncTypeInfo struct {
	ParamTypes []RugoType
	ReturnType RugoType
}

type RugoType int

type SandboxConfig struct {
	RO      []string // read-only paths
	RW      []string // read-write paths
	ROX     []string // read + execute paths
	RWX     []string // read + write + execute paths
	Connect []int    // allowed TCP connect ports
	Bind    []int    // allowed TCP bind ports
	Env     []string // allowed environment variable names
	EnvSet  bool     // true when env: was explicitly specified (even if empty)
}

type TypeInfo struct {
	// ExprTypes maps expressions to their inferred types.
	ExprTypes map[ast.Expr]RugoType
	// FuncTypes maps function names to their inferred signatures.
	FuncTypes map[string]*FuncTypeInfo
	// VarTypes maps (scope, variable name) to their final inferred type.
	// Scope is the function name (or "" for top-level).
	VarTypes map[string]map[string]RugoType
}