Miscellaneous machinery around traversing & querying the build hierarchy, that should not be needed by normal users of Mill

Aggregation of mandatoryIvyDeps and ivyDeps. In most cases, instead of overriding this Target you want to override ivyDeps instead.

All individual source files fed into the Java compiler

The exact id of the artifact to be published. You probably don't want to override this. If you want to customize the name of the artifact, override artifactName instead. If you want to customize the scala version in the artifact id, see ScalaModule.artifactScalaVersion

Override this to change the published artifact id. For example, by default a scala module foo.baz might be published as foo-baz_2.12 and a java module would be foo-baz. Setting this to baz would result in a scala artifact baz_2.12 or a java artifact baz.

Bind a dependency (Dep) to the actual module contetxt (e.g. the scala version and the platform suffix)

Use to fill most fields of BuildTarget.

Use to populate the BuildTarget.{dataKind,data} fields.

Mill specific implementations: - JvmBuildTarget - ScalaBuildTarget

The path to the compiled classes by compile without forcing to actually run the compilation. This is safe in an BSP context, as the compilation done later will use the exact same compilation settings, so we can safely use the same path.

Keep in sync with compile

Same as compileClasspath, but does not trigger compilation targets, if possible.

Keep in sync with compileClasspath

Same as localClasspath, but with all dependencies on compile replaced by their non-compiling bspCompileClassesPath variants.

Keep in sync with localClasspath

Same as localRunClasspath but for use in BSP server.

Keep in sync with localRunClasspath

Same as transitiveCompileClasspath, but with all dependencies on compile replaced by their non-compiling bspCompileClassesPath variants.

Keep in sync with transitiveCompileClasspath

Same as transitiveLocalClasspath, but with all dependencies on compile replaced by their non-compiling bspCompileClassesPath variants.

Keep in sync with transitiveLocalClasspath

Compiles the current module to generate compiled classfiles/bytecode.

When you override this, you probably also want/need to override bspCompileClassesPath, as that needs to point to the same compilation output path.

Keep in sync with bspCompileClassesPath

All classfiles and resources from upstream modules and dependencies necessary to compile this module.

Keep in sync with bspCompileClasspath

Same as ivyDeps, but only present at compile time. Useful for e.g. macro-related dependencies like scala-reflect that doesn't need to be present at runtime

The folders where the compile time resource files for this module live. If your resources files do not necessarily need to be seen by the compiler, you should use resources instead.

Customize the coursier file cache.

This is rarely needed to be changed, but sometimes e.g you want to load a coursier plugin. Doing so requires adding to coursier's classpath. To do this you could use the following:

override def coursierCacheCustomizer = T.task {
   Some( (fc: coursier.cache.FileCache[Task]) =>
     fc.withClassLoaders(Seq(classOf[coursier.cache.protocol.S3Handler].getClassLoader))
   )
}

The name of the default command, which will be automatically excecuted if the module name is provided at the Mill command line

Control whether docJar-target should use a file to pass command line arguments to the javadoc tool. Defaults to true on Windows. Beware: Using an args-file is probably not supported for very old javadoc versions.

Extra directories to be copied into the documentation.

Typically includes static files such as html and markdown, but depends on the doc tool that is actually used.

Directories to be processed by the API documentation tool.

Typically includes the source files to generate documentation from.

Any command-line parameters you want to pass to the forked JVM under run, test or repl

Any environment variables you want to pass to the forked JVM under run, test or repl

Contribute components to idea config files.

Contribute facets to the Java module configuration.

Any ivy dependencies you want to add to this Module, in the format ivy"org::name:version" for Scala dependencies or ivy"org:name:version" for Java dependencies

Options to pass to the java compiler

Additional options to be used by the javadoc tool. You should not set the -d setting for specifying the target directory, as that is done in the docJar target.

Builds a command-line "launcher" file that can be used to run this module's code, without the Mill process. Useful for deployment & other places where you do not want a build tool running

The *output* classfiles/resources from this module, used for execution, excluding upstream modules and third-party dependencies, but including unmanaged dependencies.

This is build from localCompileClasspath and localRunClasspath as the parts available "before compilation" and "after compiliation".

Keep in sync with bspLocalClasspath

The part of the localClasspath which is available "after compilation".

Keep in sync with bspLocalRunClasspath

Allows you to specify an explicit main class to use for the run command. If none is specified, the classpath is searched for an appropriate main class to use if one exists

Mandatory ivy dependencies that are typically always required and shouldn't be removed by overriding ivyDeps, e.g. the scala-library in the ScalaModule.

Map dependencies before resolving them. Override this to customize the set of dependencies.

The direct dependencies of this module. This is meant to be overridden to add dependencies. To read the value, you should use moduleDepsChecked instead, which uses a cached result which is also checked to be free of cycle.

Same as moduleDeps but checked to not contain cycles. Prefer this over using moduleDeps directly.

What platform suffix to use for publishing, e.g. _sjs for Scala.js projects

What shell script to use to launch the executable generated by assembly. Defaults to a generic "universal" launcher that should work for Windows, OS-X and Linux

Task that print the transitive dependency tree to STDOUT. NOTE: that when whatDependsOn is used with inverse it will just be ignored since when using whatDependsOn the tree _must_ be inversed to work, so this will always be set as true.

The repositories used to resolved dependencies with resolveDeps().

Customize the coursier resolution resolution process. This is rarely needed to changed, as the default try to provide a highly reproducible resolution process. But sometime, you need more control, e.g. you want to add some OS or JDK specific resolution properties which are sometimes used by Maven and therefore found in dependency artifact metadata. For example, the JavaFX artifacts are known to use OS specific properties. To fix resolution for JavaFX, you could override this task like the following:

override def resolutionCustomizer = T.task {
  Some( (r: coursier.core.Resolution) =>
    r.withOsInfo(coursier.core.Activation.Os.fromProperties(sys.props.toMap))
  )
}

Task that resolves the given dependencies using the repositories defined with repositoriesTask.

The folders where the resource files for this module live. If you need resources to be seen by the compiler, use compileResources.

Runs this module's code in a subprocess and waits for it to finish

Runs this module's code in a background process, until it dies or runBackground is used again. This lets you continue using Mill while the process is running in the background: editing files, compiling, and only re-starting the background process when you're ready.

You can also use -w foo.runBackground to make Mill watch for changes and automatically recompile your code & restart the background process when ready. This is useful when working on long-running server processes that would otherwise run forever

If true, stdout and stderr of the process executed by runBackground or runMainBackground is sent to mill's stdout/stderr (which usualy flow to the console).

If false, output will be directed to files stdout.log and stderr.log in runBackground.dest (or runMainBackground.dest)

All classfiles and resources from upstream modules and dependencies necessary to run this module's code after compilation

Runs this module's code in a subprocess and waits for it to finish

Additional dependencies, only present at runtime. Useful for e.g. selecting different versions of a dependency to use at runtime after your code has already been compiled.

Runs this module's code in-process within an isolated classloader. This is faster than run, but in exchange you have less isolation between runs since the code can dirty the parent Mill process and potentially leave it in a bad state.

Same as run, but lets you specify a main class to run

Same as runBackground, but lets you specify a main class to run

Same as runLocal, but lets you specify a main class to run

Control whether run*-targets should use an args file to pass command line args, if possible.

Scalac options to activate the compiler plugins.

Show the module dependencies.

Skip Idea project file generation.

The transitive ivy dependencies of this module and all it's upstream modules. This is calculated from ivyDeps, mandatoryIvyDeps and recursively from moduleDeps.

All direct and indirect module dependencies of this module, including compile-only dependencies: basically the modules whose classpath are needed at compile-time.

Note that compileModuleDeps are defined to be non-transitive, so we only look at the direct compileModuleDeps when assembling this list

Build the assembly for upstream dependencies separate from the current classpath

This should allow much faster assembly creation in the common case where upstream dependencies do not change

The upstream compilation output of all this module's upstream modules

Files extensions that need to be managed by Zinc together with class files. This means, if zinc needs to remove a class file, it will also remove files which match the class file basename and a listed file extension.

If true, we always show problems (errors, warnings, infos) found in all source files, even when they have not changed since the previous incremental compilation. When false, we report only problems for files which we re-compiled.