pipeline

type Artifacts struct {
	AST    *ast.File
	Core   *core.Program
	CoreTI types.CoreTypeInfo // M-DX23: Type info for Core expressions (for typed codegen)
	Typed  interface{}        // TODO: Add typed AST when available
	Linked interface{}        // TODO: Add linked program when available
}

type CacheEntry struct {
	CacheKey      string    `json:"cache_key"`
	IfaceDigest   string    `json:"iface_digest"`
	IfaceJSON     []byte    `json:"iface_json,omitempty"`
	CompileTimeMs int64     `json:"compile_time_ms"`
	Timestamp     time.Time `json:"timestamp"`
}

type CacheManifest struct {
	Version string                 `json:"version"`
	Entries map[string]*CacheEntry `json:"entries"`
}

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

type CachedModule struct {
	Core         *core.Program               // Core IR (gob-encoded on disk)
	CoreTI       types.CoreTypeInfo          // Type info for Core nodes (JSON-encoded)
	Iface        *iface.Iface                // Module interface
	Constructors map[string]*ConstructorInfo // ADT constructors
}

type CompileUnit struct {
	ID           string                      // Module ID/path
	Surface      *ast.File                   // Parsed AST
	Core         *core.Program               // Core representation
	CoreTI       types.CoreTypeInfo          // M-DX23: Type info for Core expressions
	Iface        *iface.Iface                // Module interface
	TypeEnv      interface{}                 // Type environment (placeholder)
	Constructors map[string]*ConstructorInfo // ADT constructors defined in this module
}

type Config struct {
	Mode                    Mode                  // Execution mode (Check or Eval)
	JSON                    bool                  // Output JSON format
	Compact                 bool                  // Use compact JSON
	DumpCore                bool                  // Show Core AST
	DumpCoreLowered         bool                  // Show Core after lowering
	DumpTyped               bool                  // Show Typed AST
	TraceDefaulting         bool                  // Trace type defaulting
	DryLink                 bool                  // Show linking without eval
	RequireLowering         bool                  // Fail if operators not lowered
	ExperimentalBinopShim   bool                  // Feature flag for operator shim
	FailOnShim              bool                  // Fail if shim would be used (CI mode)
	TrackInstantiations     bool                  // Track polymorphic type instantiations
	LedgerHook              func(decision string) // Optional decision hook
	DisableMonomorphization bool                  // Disable monomorphization pass (emergency escape hatch)
	DisableVarResolution    bool                  // Disable Var type resolution (M-DX4 workaround, default enabled)
	DebugCompile            bool                  // Show compilation statistics (specialization counts, etc.)
	StrictSyntaxMode        bool                  // Disable syntactic sugar (require canonical syntax)
	RelaxModules            bool                  // Relax MOD010 validation (allow module path mismatches with warning)
	NoCache                 bool                  // M-PERF6: Disable compilation cache (--no-cache)
	ReleaseMode             bool                  // M-DEBUG-ERASURE: Erase Debug ghost effect (--release)

	// M-DX11: Type debugging
	DebugTypes     bool   // Enable type inference debugging output
	DebugTypesNode uint64 // Filter debug output to specific node (0 = all nodes)

	// Environment from REPL (optional)
	TypeEnv   *types.TypeEnv
	InstEnv   *types.InstanceEnv
	DictReg   *types.DictionaryRegistry
	Instances map[string]core.DictValue
	EvalEnv   *eval.Environment

	// Global resolver for non-module evaluation (v0.2.0 hotfix)
	GlobalResolver eval.GlobalResolver
	// contains filtered or unexported fields
}

type ConstructorInfo struct {
	TypeName           string       // ADT type name (e.g., "Option")
	CtorName           string       // Constructor name (e.g., "Some")
	FieldTypes         []ast.Type   // Field types from AST
	Arity              int          // Number of fields
	TypeParamCount     int          // M-TAPP-FIX: Number of type parameters (e.g., Option[a] = 1)
	TypeParamNames     []string     // M-POLY-ADT: Type parameter names (e.g., ["a"] for Result[a])
	InternalFieldTypes []types.Type // M-POLY-ADT: Actual field types for type scheme building
}

type CoreSanityError struct {
	Code       string
	Message    string
	NodeID     uint64
	Suggestion string
}

type DebugEraser struct{}

type FallbackEvent struct {
	Op       core.IntrinsicOp
	NodeID   uint64
	Fallback string // "CoreTI-hit", "ResolvedConstraints", "Default"
	Location string // Source location if available
}

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

type Mode int

type OpLowerer struct {
	CoreTI types.CoreTypeInfo // Core NodeID → inferred types (for type-guided lowering)
	// contains filtered or unexported fields
}

type OpMapping struct {
	Builtin string   // Base builtin name (e.g., "add")
	Types   []string // Supported types (e.g., ["Int", "Float"])
}

type PipelineMetrics struct {
	// Timing metrics (milliseconds)
	// Single-file pipeline phases
	LexTime       int64 `json:"lex_ms,omitempty"`
	ParseTime     int64 `json:"parse_ms,omitempty"`
	ElaborateTime int64 `json:"elaborate_ms,omitempty"`
	TypeCheckTime int64 `json:"typecheck_ms,omitempty"`
	DictElabTime  int64 `json:"dict_elab_ms,omitempty"`
	MonomorphTime int64 `json:"monomorph_ms,omitempty"`
	LowerTime     int64 `json:"lower_ms,omitempty"`
	LinkTime      int64 `json:"link_ms,omitempty"`
	ANFVerifyTime int64 `json:"anf_verify_ms,omitempty"`

	// Module pipeline phases
	LoadTime    int64 `json:"load_ms,omitempty"`    // Module loading (for multi-module)
	TopoTime    int64 `json:"topo_ms,omitempty"`    // Topological sort
	CompileTime int64 `json:"compile_ms,omitempty"` // All modules compilation (aggregate)

	// Shared phases
	EvalTime  int64 `json:"eval_ms,omitempty"`
	TotalTime int64 `json:"total_ms"`

	// Resource metrics
	MemoryDeltaBytes int64 `json:"memory_delta_bytes"`
	AllocsCount      int64 `json:"allocs_count"`

	// Compilation stats
	ModulesCompiled  int `json:"modules_compiled"`
	Specializations  int `json:"specializations"`
	OperatorsLowered int `json:"operators_lowered"`

	// Context
	Filename  string `json:"filename"`
	IsModule  bool   `json:"is_module"`
	Timestamp int64  `json:"timestamp"`
}

type Result struct {
	Value          eval.Value
	Type           types.Type
	Constraints    []types.Constraint
	Errors         []error                            // TODO: Use structured errors
	Warnings       []*elaborate.ExhaustivenessWarning // Exhaustiveness warnings
	Artifacts      Artifacts
	Interface      *iface.Iface                    // Module interface (for modules only)
	Modules        map[string]*loader.LoadedModule // Loaded modules with Core (for module execution)
	EnvLockDigest  string
	PhaseTimings   map[string]int64       // milliseconds
	Instantiations map[string]interface{} // Polymorphic instantiation tracking

	// M-DX11: Type debugging
	TypeChecker *types.CoreTypeChecker  // Type checker (for debug output)
	DebugSink   *types.VerboseDebugSink // Debug events (when DebugTypes enabled)

	// M-DX19: Dictionary registry with derived type class instances
	DictReg *types.DictionaryRegistry
}

type SkipReason struct {
	DefSym   string // Function symbol
	Reason   string // Human-readable reason
	Location string // Source location (if available)
}

type Source struct {
	Code     string
	Filename string
	IsREPL   bool
	REPLNum  int // REPL snippet number
}

type SpecializationKey struct {
	DefSym           string // Original function symbol
	TypesFingerprint string // Canonical fingerprint of argument types
}

type SpecializationLimits struct {
	MaxPerFunction int // Maximum specializations per function (default: 16)
	MaxPerModule   int // Maximum specializations per module (default: 512)
}

type SpecializationStats struct {
	TotalSpecializations int
	PerFunction          map[string]int
	SkippedFunctions     []SkipReason
	CacheHits            int
	CacheMisses          int
}

type Specializer struct {
	CoreTI      *types.CoreTypeInfo                 // Type information for Core nodes
	Cache       map[SpecializationKey]core.CoreExpr // Memoization cache
	PerFunction map[string]int                      // Count specializations per function
	TotalCount  int                                 // Total specialization count
	Limits      SpecializationLimits                // Resource limits
	Skipped     []SkipReason                        // Functions skipped (for diagnostics)

	CacheHits   int // Number of cache hits
	CacheMisses int // Number of cache misses
	// contains filtered or unexported fields
}

type ValidationGap struct {
	NodeID   uint64
	ExprKind string // "Lit(Float)", "Intrinsic(OpLe)", "Var", etc.
	Position string // From OriginalSpan() if available
	Hint     string // Actionable suggestion for fixing
	IsStrict bool   // If false, only warn (for unreachable code in future)
}

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