A Graph of ResolvedModuleNames, representing the relationships between all modules currently loaded or involved in the current build action. Modules are only added here after they have been locally traced successfully.

pollForAbort

val pollForAbort: () -> Boolean

A function for polling for abort requests.

runtime

val runtime: AvailRuntime

The runtime into which the builder will install the target module and its dependencies.

shouldStopBuild

val shouldStopBuild: Boolean

true iff the current build should stop, false otherwise.

stopBuildReason

var stopBuildReason: String?

The reason why the current build should stop, or null if a stop is not currently requested.

textInterface

var textInterface: TextInterface

The text interface for the builder and downstream components.

Functions

attemptCommand

fun attemptCommand(command: String, onAmbiguity: (List<AvailBuilder.CompiledCommand>, (AvailBuilder.CompiledCommand?) -> Unit) -> Unit, onSuccess: (AvailObject, (() -> Unit) -> Unit) -> Unit, onFailure: () -> Unit)

Attempt to unambiguously parse a command. Each currently loaded module that defines at least one entry point takes a shot at parsing the command. If more than one is successful, report the ambiguity via the onFailure continuation. If none are successful, report the failure. If there was exactly one, compile it into a function and invoke it in a new fiber. If the function evaluation succeeds, run the onSuccess continuation with the function's result, except that if the function has static type ⊤ always pass nil instead of the actual value returned by the function. If the function evaluation failed, report the failure.

buildTarget

fun buildTarget(target: ModuleName, localTracker: CompilerProgressReporter, globalTracker: GlobalProgressReporter, problemHandler: ProblemHandler)

Build the target and its dependencies. Block the current Thread until it's done.

buildTargetThen

fun buildTargetThen(target: ModuleName, localTracker: CompilerProgressReporter, globalTracker: GlobalProgressReporter, problemHandler: ProblemHandler, originalAfterAll: () -> Unit)

fun buildTargetThen(targets: Set<ModuleName>, localTracker: CompilerProgressReporter, globalTracker: GlobalProgressReporter, problemHandler: ProblemHandler, originalAfterAll: () -> Unit)

Build the target and its dependencies.

cancel

fun cancel()

Cancel the build at the next convenient stopping point for each module.

checkStableInvariants

fun checkStableInvariants()

Check any invariants of the builder that should hold when it is idle.

generateDocumentation

fun generateDocumentation(target: ModuleName, documentationPath: Path, problemHandler: ProblemHandler)

Generate Stacks documentation for the target and its dependencies.

generateGraph

fun generateGraph(target: ResolvedModuleName, destinationFile: File, problemHandler: ProblemHandler)

Generate a graph.

getLoadedModule

fun getLoadedModule(resolvedModuleName: ResolvedModuleName): AvailBuilder.LoadedModule?

Look up the currently loaded module with the specified resolved module name. Return null if the module is not currently loaded.

loadedModulesCopy

fun loadedModulesCopy(): List<AvailBuilder.LoadedModule>

Return a list of modules that are currently loaded. The returned list is a snapshot of the state and does not change due to subsequent loads or unloads.

subscribeToModuleLoading

fun subscribeToModuleLoading(subscription: (AvailBuilder.LoadedModule, Boolean) -> Unit)

Record a new party to notify about module loading and unloading.

traceDirectoriesThen

fun traceDirectoriesThen(action: (ResolvedModuleName, ModuleVersion, () -> Unit) -> Unit, afterAll: () -> Unit)

Scan all module files in all visible source directories, passing each ResolvedModuleName and corresponding ModuleVersion to the provided function.

unloadTarget

fun unloadTarget(target: ResolvedModuleName?)

Unload the target module and its dependents. If null is provided, unload all modules.

unsubscribeToModuleLoading

fun unsubscribeToModuleLoading(subscription: (AvailBuilder.LoadedModule, Boolean) -> Unit)

No longer notify the specified party about module loading and unloading.