CompilationContext

The abstract class for the styling state machine. A statement can be in the process of being styled while the next statement is being parsed, but before that next statement is allowed to executed, the previous styling action must complete. Otherwise, the execution of the next statement might change the stylers that are in effect while the styling of the previous statement is in progress, which is a race.

A styling activity is starting. Note that styling must always be started causally beforewhenNotStyling may be called.

Clear the cache of method -> style function. This can be done either when a new style is added within scope of this module, or just before styling a top-level statement.

Generate a function from the specified phrase and evaluate it in the module's context; lexically enclosing variables are not considered in scope, but module variables and constants are in scope.

Attempt the zero-argument continuation. The implementation is free to execute it now or to put it in a bag of continuations to run later in an arbitrary order. There may be performance and/or scale benefits to processing entries in FIFO, LIFO, or some hybrid order, but the correctness is not affected by a choice of order. The implementation may run the expression in parallel with the invoking thread and other such expressions.

The current styling activity has completed. If there was a post-styling action set, run it after transitioning to NotStyling.

Flush the delayedSerializedEarlyEffects and delayedSerializedEffects to top-level functions that perform those actions.

Given a method, look up stylers visible by the current module, and choose the most specific one, or the conflict styler if there is more than one that is most specific. Answer nil if none are defined and visible to the module.

Record the fact that this token was encountered while parsing the current top-level statement.

Start N work units, which are about to be queued.

Apply the style for a single method send phrase, without considering its subphrases.

Process all of the phrase's subphrases recursively, then style the phrase itself, then invoke the given action.

A styling action might still be running. If it is, ensure the action is executed after the styling completes. If it was not styling, run the action immediately.

Construct and answer a function that wraps the specified continuation in logic that will increment the count of completed work units and potentially call the unambiguous statement.

Eventually execute the specified List of functions as compiler work units. Note that the queued work unit count must be increased by the full amount up-front to ensure the completion of the first N tasks before the N+1st can be queued doesn't trigger execution of noMoreWorkUnits. Each continuation will be passed the same given argument.

The CompilerDiagnostics that tracks potential errors during compilation.

The loader created and operated by this compiler to facilitate the loading of modules.

The Avail module undergoing compilation.

The header information for the current module being parsed.

What to do when there are no more work units.

The CompilerProgressReporter that reports compilation progress at various checkpoints. It accepts the name of the module undergoing compilation, the line number on which the last complete statement concluded, the position of the ongoing parse (in bytes), and the size of the module (in bytes).

The AvailRuntime for the compiler. Since a compiler cannot migrate between two runtime environments, it is safe to cache it for efficient access.

The output stream on which the serializer writes.

A tool for converting character positions between Avail's Unicode strings and Java/Kotlin's UTF-16 representation.

The text interface for any fibers started by this compiler.

The current number of work units that have been completed.

The current number of work units that have been queued.