mill.api

Represents an unstructured sequence of command-line arguments that can be passed to Mill commands; similar to mainargs.Leftover.

BuildCtx contains APIs that are global throughout an entire build, without being tied to any particular task or module

Models "cross-builds": sets of duplicate builds which differ only in the value of one or more "case" variables whose values are determined at runtime. Used via:

object foo extends Cross[FooModule]("bar", "baz", "qux")
trait FooModule extends Cross.Module[String]{
 ... crossValue ...
}

Models the different kinds of cross-versions supported by Mill for Scala dependencies.

A Module that has a defaultTask that will be automatically executed if the module name is provide at the Mill command line

Macro to walk the module tree and generate mainargs entrypoints for any Task.Command methods that it finds. Needs to be provided for every ExternalModule that you define.

Note that unlike the rest of Mill's module-handling logic which uses Java reflection, generation of entrypoints requires typeclass resolution, and so needs to be done at compile time. Thus, we walk the entire module tree, collecting all the module Class[_]s we can find, and for each one generate the mainargs.MainData containing metadata and resolved typeclasses for all the Task.Command methods we find. This mapping from Class[_] to MainData can then be used later to look up the MainData for any module.

A module which you can override moduleDirectChildren to dynamically enable or disable child modules at runtime

An implicit that provides the lexically-enclosing class at the point at which it is resolved

An API that allows you to resolve, plan, and execute Mill tasks.

Evaluator can be taken as a parameter to Task.Commands marked as exclusive = true, providing those commands with the ability to inspect the build and dynamically decide what to evaluate. Many builtin commands like show, plan, path, etc. are implemented in this way

Logic to resolve a Task's Segments to the various paths on disk owned by that task.

The output of executing tasks via an Evaluator

A module defined outside of the build.mill file, and is instead provided builtin by some Mill library or plugin

Implementors should make sure, the final override of millDiscover happens in the final object.

  override protected def millDiscover: Discover = Discover[this.type]

Defines various default JSON formatters used in mill.

Represents a namespace within the Mill build hierarchy, containing nested modules or tasks.

Module is a class meant to be extended by traits only, in order to propagate the implicit parameters forward to the final concrete instantiation site so they can capture the enclosing/line information of the concrete instance.

The contextual information provided to a mill.api.Module or mill.api.Task

Used to refer to a module from another module without including the target module as a child-module of the first.

A wrapper around os.Path that calculates it's hashcode based on the contents of the filesystem underneath it. Used to ensure filesystem changes can bust caches which are keyed off hashcodes.

Represents the outcome of Mill planning: a MultiBiMap containing the transitive tasks upstream of the tasks selected by the user, grouped by the "terminal" named or selected task downstream of each group

Utilities for managing and redirecting the SystemStreams modelling the stdin/stdout/stderr of the process

Models a single node in the Mill build graph, with a list of inputs and a single output of type T.

Generally not instantiated manually, but instead constructed via the Task.apply & similar macros.

Represents the data and utilities that are contextually available inside the implementation of a Task.

Provides access to various resources in the context of a current execution task.

Represents the topologically sorted set of tasks