ctn

type CleanRegistry interface {
	Register(closeable io.Closer)
}

type Cleaner interface {
	CleanRegistry

	// Closes all registered closers.
	Clean() (err error)
}

type DI = *dig.Container

type DICommonUtil struct {
	DI
}

type InputFS fsal.FS

type OutputFS fsal.FS

type SimpleStage struct {
	InitializeImpl func(ctx StageContext) (err error)
	CompileImpl    func(ctx StageContext, c DI) (err error)
	RewriteImpl    func(ctx StageContext, current DI, newContainer DI) (err error)
	ShutdownImpl   func(ctx StageContext, c DI) (err error)
}

type Stage interface {
	// Initializes container.
	// Called before rewriting of previous container is performed.
	Initialize(ctx StageContext) (err error)

	// Performs actual compilation - registers DI types, which
	// are result of compilation.
	Compile(ctx StageContext) (err error)

	// Rewrites all entries from current DI container to next stage's DI container.
	// So that all redundant dependencies are dropped.
	//
	// Called after compile.
	Rewrite(ctx StageContext, newContainer DI) (err error)

	// Shutdowns DI container.
	// This function must perform any kind of cleanup.
	Shutdown(ctx StageContext) (err error)
}

type StageContext interface {
	context.Context
	// Returns compilation-wide DI container.
	GetGlobalContainer() DI
	GetStageContanier() DI
}

type StagedCompiler struct {
	InitializeGlobalContainer func(ctx context.Context, globalDI DI) (err error)
	Stages                    []Stage
}

type StagedCompilerResult struct {
	LastStageDI DI
	GlobalDI    DI
}