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 Java source files fed into the compiler. Subset of allSourceFiles.

All individual Kotlin source files fed into the compiler. Subset of allSourceFiles.

All individual source files fed into the compiler.

The folders containing all source files fed into the compiler

Specifies AAPT options for Android resource compilation.

Optimizes the APK using the zipalign tool for better performance.

For more details on the zipalign tool, refer to: zipalign Documentation

Signs the APK using a keystore to generate a final, distributable APK.

The signing step is mandatory to distribute Android applications. It adds a cryptographic signature to the APK, verifying its authenticity. This method uses the apksigner tool along with a keystore file to sign the APK.

If no keystore is available, a new one is generated using the keytool utility.

For more details on the apksigner tool, refer to: apksigner Documentation

This setting defines which Android API level your project compiles against. This is a required property for Android builds.

It determines what Android APIs are available during compilation - your code can only use APIs from this level or lower.

See https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels for more details.

The device id as listed from avdmanager list device. Default is medium_phone

Converts the generated JAR file into a DEX file using the d8 tool.

The target architecture of the virtual device to be created by createAndroidVirtualDevice For example, "x86_64" (default). For a list of system images and their architectures, see the Android SDK Manager sdkmanager --list.

The emulator port where adb connects to. Defaults to 5554

Enable Jetpack Compose support in the module. Default is false.

Installs the app to the android device identified by this configuration in androidVirtualDeviceIdentifier.

Controls debug vs release build type. Default is true, meaning debug build will be generated.

This option will probably go away in the future once build variants are supported.

Collect files from META-INF folder of classes.jar (not META-INF of aar in case of Android library).

Determines whether the build should fail if Android Lint detects any issues.

Specifies additional arguments for the Android Lint tool. Allows for complete customization of the lint command.

Specifies the lint baseline XML file path. This allows using a baseline to suppress known lint warnings.

Specifies the lint configuration XML file path. This allows setting custom lint rules or modifying existing ones.

Specifies the file format(s) of the lint report. Available file formats are defined in AndroidLintReportFormat, such as AndroidLintReportFormat.Html, AndroidLintReportFormat.Xml, AndroidLintReportFormat.Txt, and AndroidLintReportFormat.Sarif.

Runs the Android Lint tool to generate a report on code quality issues.

This method utilizes Android Lint, a tool provided by the Android SDK, to analyze the source code for potential bugs, performance issues, and best practices compliance. It generates a report in the specified format.

The report is saved in the task's destination directory as "report.html" by default. It can be changed to other file format such as xml, txt and sarif.

For more details on the Android Lint tool, refer to: https://developer.android.com/studio/write/lint

Provides os.Path to an XML file containing configuration and metadata about your android application.

Creates a merged manifest from application and dependencies manifests.

See https://developer.android.com/build/manage-manifests for more details.

The minimum SDK version to use. Default is 1.

See https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#min for more details.

Name of the key alias in the release keystore. Default is not set.

Name of the release keystore file. Default is not set.

Password for the release key. Default is not set.

Default os.Path to the keystore file, derived from androidReleaseKeyName(). Users can customize the keystore file name to change this path.

Password for the release keystore. Default is not set.

Compiles Android resources and generates R.java and res.apk.

Defines a list of specifications to create previews against.

For more information see https://developer.android.com/studio/preview/compose-screenshot-testing

The location that the renderer results summary is, in the test engine's expected format i.e. by renaming the screenshotResults key to screenshots

Provides access to the Android SDK configuration.

Generates the command-line arguments required for Android app signing.

Uses the release keystore if release build type is set; otherwise, defaults to a generated debug keystore.

The target SDK version to use. Default is equal to the androidCompileSdk value.

See https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#target for more details.

Extracts JAR files and resources from AAR dependencies.

Packages DEX files and Android resources into an unsigned APK.

Version code of the application. Default is 1.

See https://developer.android.com/studio/publish/versioning for more details.

The version name of the application. Default is "1.0".

See https://developer.android.com/studio/publish/versioning for more details.

The name of the virtual device to be created by createAndroidVirtualDevice

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.

The suffix appended to the artifact IDs during publishing

Adds "aar" to the handled artifact types.

An executable uber-jar/assembly containing all the resources and compiled classfiles from this module and all it's upstream modules and dependencies

Configuration for the assembly task: how files and file-conflicts are managed when combining multiple jar files into one big assembly jar.

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

Any Bill of Material (BOM) dependencies you want to add to this Module, in the format ivy"org:name:version"

Bill of Material (BOM) dependencies of this module. This is meant to be overridden to add BOM dependencies. To read the value, you should use bomModuleDepsChecked instead, which uses a cached result which is also checked to be free of cycles.

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

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 all the sources to JVM class files.

Replaces AAR files in classpath with their extracted JARs.

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 compile-only direct dependencies of this module. These are *not* transitive, and only take effect in the module that they are declared in.

Same as compileModuleDeps but checked to not contain cycles.

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.

The compose-preview-renderer jar executable that generates the screenshots. For more information see https://developer.android.com/studio/preview/compose-screenshot-testing

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 = Task.Anon {
   Some( (fc: coursier.cache.FileCache[Task]) =>
     fc.withClassLoaders(Seq(classOf[coursier.cache.protocol.S3Handler].getClassLoader))
   )
}

The coursier.Dependency to use to refer to this module

The coursier.Project corresponding to this JavaModule.

This provides details about this module to the coursier resolver (details such as dependencies, BOM dependencies, dependency management, etc.). Beyond more general resolution parameters (such as artifact types, etc.), this should be the only way we provide details about this module to coursier.

Creates the android virtual device identified in virtualDeviceIdentifier

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

Deletes the android device

Dependency management data

Versions and exclusions in dependency management override those of transitive dependencies, while they have no effect if the corresponding dependency isn't pulled during dependency resolution.

For example, the following forces com.lihaoyi::os-lib to version 0.11.3, and excludes org.slf4j:slf4j-api from com.lihaoyi::cask that it forces to version 0.9.4

def depManagement = super.depManagement() ++ Agg(
  ivy"com.lihaoyi::os-lib:0.11.3",
  ivy"com.lihaoyi::cask:0.9.5".exclude("org.slf4j", "slf4j-api")
)

Overridden since Junit5 has its own discovery mechanism.

This is basically a re-implementation of sbt's plugin for Junit5 test discovery mechanism. See https://github.com/sbt/sbt-jupiter-interface/blob/468d4f31f1f6ce8529fff8a8804dd733974c7686/src/plugin/src/main/scala/com/github/sbt/junit/jupiter/sbt/JupiterPlugin.scala#L97C15-L118 for details.

Note that we access the test discovery via reflection, to avoid mill itself having a dependency on Junit5. Hence, if you remove the sbt-jupiter-interface dependency from ivyDeps, make sure to also override this method.

The documentation jar, containing all the Dokka HTML files, for publishing to Maven Central. You can control Dokka version by using dokkaVersion and option by using dokkaOptions.

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.

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

Dokka version.

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

Similar to forkArgs but only applies to the bat launcher script

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

Similar to forkArgs but only applies to the sh launcher script

Combines standard Java source directories with additional sources generated by the Android resource generation step.

Contribute components to idea config files.

Contribute facets to the Java module configuration.

The repository that knows about this project itself and its module dependencies

Mill internal repositories to be used during dependency resolution

These are not meant to be modified by Mill users, unless you really know what you're doing.

Command to print the transitive dependency tree to STDOUT.

A jar containing only this module's resources and compiled classfiles, without those from upstream modules and 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.

The compiler API version. Default is not set.

The actual Kotlin compile task (used by compile and kotlincHelp).

The Java classpath resembling the Kotlin compiler. Default is derived from kotlinCompilerIvyDeps.

The Ivy/Coursier dependencies resembling the Kotlin compiler. Default is derived from kotlinCompilerVersion.

The version of the Kotlin compiler to be used. Default is derived from kotlinVersion.

Flag to use explicit API check in the compiler. Default is false.

The compiler language version. Default is not set.

The Kotlin version to be used (for API and Language level settings).

Runs the Kotlin compiler with the -help argument to show you the built-in cmdline help. You might want to add additional arguments like -X to see extra help.

Additional Kotlin compiler options to be used by compile.

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 compilation".

Keep in sync with bspLocalClasspath

The *input* classfiles/resources from this module, used during compilation, excluding upstream modules and third-party dependencies

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

The dependencies of this module. Defaults to add the kotlin-stdlib dependency matching the kotlinVersion.

Additional options for the java compiler derived from other module settings.

Creates a manifest representation which can be modified or replaced The default implementation just adds the Manifest-Version, Main-Class and Created-By attributes

Classpath for the manifest merger run.

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.

Data from depManagement, converted to a type ready to be passed to coursier for dependency resolution

The direct and indirect dependencies of this module

The direct and indirect runtime module dependencies of this module

The repositories used to resolved dependencies with resolveDeps().

Customize the coursier 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 = Task.Anon {
  Some( (r: coursier.core.Resolution) =>
    r.withOsInfo(coursier.core.Activation.Os.fromProperties(sys.props.toMap))
  )
}

Resolution parameters, allowing to customize resolution internals

This rarely needs to be changed. This allows to disable the new way coursier handles BOMs since coursier 2.1.17 (used in Mill since 0.12.3) for example, with:

def resolutionParams = super.resolutionParams()
  .withEnableDependencyOverrides(Some(false))

Note that versions forced with Dep#forceVersion() take over forced versions manually set in resolutionParams. The former should be favored to force versions in dependency resolution.

The Scala version set via ScalaModule#scalaVersion also takes over any Scala version provided via ResolutionParams#scalaVersionOpt.

The default configuration set in ResolutionParams#defaultConfiguration is ignored when Mill fetches dependencies to be passed to the compiler (equivalent to Maven "compile scope"). In that case, it forces the default configuration to be "compile". On the other hand, when fetching dependencies for runtime (equivalent to Maven "runtime scope"), the value in ResolutionParams#defaultConfiguration is used.

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

Resolved dependencies

Combines module resources with those unpacked from AARs.

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 usually 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

The runtime-only direct dependencies of this module. These *are* transitive, and so get propagated to downstream modules automatically

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

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

Returns the emulator identifier for created from startAndroidEmulator by iterating the adb device list

Installs the user specified system image for the emulator using sdkmanager . E.g. "system-images;android-35;google_apis_playstore;x86_64"

Scalac options to activate the compiler plugins.

Show the module dependencies.

Skip Idea project file generation.

The source jar, containing only source code for publishing to Maven Central

The folders where the source files for this module live

Starts the android emulator and waits until it is booted

Stops the android emulator

Discovers and runs the module's tests in a subprocess, reporting the results to the console.

Discovers and runs the module's tests in a subprocess, reporting the results to the console. If no input has changed since the last run, no test were executed.

Args to be used by testCached.

The classpath containing the tests. This is most likely the output of the compilation target. By default, this uses the result of localRunClasspath, which is most likely the result of a local compilation.

How the test classes in this module will be split into multiple JVM processes and run in parallel during testing. Defaults to all of them running in one process sequentially, but can be overridden to split them into separate groups that run in parallel.

The test framework to use.

For convenience, you can also mix-in one of these predefined traits: - TestModule.Junit4 - TestModule.Junit5 - TestModule.Munit - TestModule.ScalaTest - TestModule.Specs2 - TestModule.TestNg - TestModule.Utest - TestModule.Weaver - TestModule.ZioTest

Discovers and runs the module's tests in-process in an isolated classloader, reporting the results to the console

Discovers and runs the module's tests in a subprocess, reporting the results to the console. Arguments before "--" will be used as wildcard selector to select test classes, arguments after "--" will be passed as regular arguments. testOnly *foo foobar bar* -- arguments will test only classes with name (includes package name) 1. end with "foo", 2. exactly "foobar", 3. start with "bar", with "arguments" as arguments passing to test framework.

Sets the file name for the generated JUnit-compatible test report. If None is set, no file will be generated.

Whether to use the test task destination folder as the working directory when running tests. true means test subprocess run in the .dest/sandbox folder of the test task, providing better isolation and encouragement of best practices (e.g. not reading/writing stuff randomly from the project source tree). false means the test subprocess runs in the project root folder, providing weaker isolation.

The actual task shared by test-tasks that runs test in a forked JVM.

Controls whether the TestRunner should receive its arguments via an args-file instead of a long parameter list. Defaults to what runUseArgsFile return.

The transitive version of compileClasspath

Coursier project of this module and those of all its transitive module dependencies

Almost the same as transitiveLocalClasspath, but using the jars instead of localClasspath.

The transitive version of localClasspath

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

Like recursiveModuleDeps but also include the module itself, basically the modules whose classpath are needed at runtime

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

Note that runModuleDeps are defined to be transitive

Like recursiveModuleDeps but also include the module itself, basically the modules whose classpath are needed at runtime

Adds the Android SDK JAR file to the classpath during the compilation process.

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

All upstream classfiles and resources necessary to build and executable assembly, but without this module's contribution

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.

Returns a function adding BOM and dependency management details of this module to a coursier.core.Dependency

The Ivy dependencies of this module, with Bill of Material (BOM) and dependency management details added to them. This should be used when propagating the dependencies transitively to other modules.

The compile-only transitive ivy dependencies of this module and all its upstream compile-only modules.

This isn't used by Mill anymore. Instead of this, consider using either: * coursierDependency().withConfiguration(Configuration.provided), which will pull all this module's compile-only dependencies transitively * compileIvyDeps, which contains the full list of direct (external) compile-only dependencies of this module

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

This isn't used by Mill anymore. Instead of this, consider using either: * coursierDependency, which will pull all this module's dependencies transitively * allIvyDeps, which contains the full list of direct (external) dependencies of this module

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

This isn't used by Mill anymore. Instead of this, consider using either: * coursierDependency().withConfiguration(Configuration.runtime), which will pull all this module's runtime dependencies transitively * runIvyDeps, which contains the full list of direct (external) runtime dependencies of this module

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

This implementation is deprecated because of it's return value. Please use upstreamAssembly2 instead.