t

mill.scalalib

JavaModule

trait JavaModule extends BaseClass with Module with define.TaskModule with GenIdeaModule with CoursierModule with OfflineSupportModule with BspModule with SemanticDbJavaModule with JavaModuleBase

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. JavaModule
  2. JavaModuleBase
  3. SemanticDbJavaModule
  4. BspModule
  5. OfflineSupportModule
  6. CoursierModule
  7. GenIdeaModule
  8. TaskModule
  9. Module
  10. BaseClass
  11. Cacher
  12. AnyRef
  13. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. trait JavaModuleTests extends BaseClass with JavaModule with TestModule

Value Members

  1. object millInternal extends Internal

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

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

    Definition Classes
    Module
    Annotations
    @internal()
  2. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  3. final def ##: Int
    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. def allIvyDeps: T[Agg[Dep]]

    Aggregation of mandatoryIvyDeps and ivyDeps.

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

  6. def allSourceFiles: T[Seq[api.PathRef]]

    All individual source files fed into the Java compiler

    All individual source files fed into the Java compiler

    Definition Classes
    JavaModuleSemanticDbJavaModule
  7. def allSources: T[Seq[api.PathRef]]

    The folders containing all source files fed into the compiler

  8. def artifactId: T[String]

    The exact id of the artifact to be published.

    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

  9. def artifactName: T[String]

    Override this to change the published artifact id.

    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.

  10. def artifactNameParts: T[Seq[String]]
  11. def artifactSuffix: T[String]

    The suffix appended to the artifact IDs during publishing

  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def assembly: T[api.PathRef]

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

  14. def assemblyRules: Seq[Rule]

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

  15. def bindDependency: define.Task[(Dep) => BoundDep]

    Bind a dependency (Dep) to the actual module contetxt (e.g.

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

    returns

    The BoundDep

    Definition Classes
    CoursierModule
  16. def bspBuildTarget: BspBuildTarget

    Use to fill most fields of BuildTarget.

    Use to fill most fields of BuildTarget.

    Definition Classes
    JavaModuleSemanticDbJavaModuleBspModule
    Annotations
    @internal()
  17. def bspBuildTargetData: define.Task[Option[(String, AnyRef)]]

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

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

    Mill specific implementations: - JvmBuildTarget - ScalaBuildTarget

    Definition Classes
    BspModule
    Annotations
    @internal()
  18. def bspCompileClassesPath: T[UnresolvedPath]

    The path to the compiled classes without forcing to actually run the target.

    The path to the compiled classes without forcing to actually run the target.

    Annotations
    @internal()
  19. def bspCompileClasspath: T[Agg[UnresolvedPath]]

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

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

    Annotations
    @internal()
  20. def bspCompiledClassesAndSemanticDbFiles: define.Target[UnresolvedPath]
    Definition Classes
    SemanticDbJavaModule
  21. def bspDisplayName: String
    Definition Classes
    BspModule
  22. def bspDisplayName0: String
    Definition Classes
    BspModule
  23. def bspLocalClasspath: T[Agg[UnresolvedPath]]

    The local classpath without forcing to compile the module.

    The local classpath without forcing to compile the module. Keep in sync with compile

    Annotations
    @internal()
  24. def bspTransitiveCompileClasspath: T[Agg[UnresolvedPath]]

    The transitive version of bspCompileClasspath

    The transitive version of bspCompileClasspath

    Annotations
    @internal()
  25. def bspTransitiveLocalClasspath: T[Agg[UnresolvedPath]]

    The transitive version of bspLocalClasspath

    The transitive version of bspLocalClasspath

    Annotations
    @internal()
  26. def cachedTarget[T](t: => T)(implicit c: Enclosing): T
    Attributes
    protected[this]
    Definition Classes
    Cacher
  27. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  28. def compile: T[CompilationResult]

    Compiles the current module to generate compiled classfiles/bytecode.

    Compiles the current module to generate compiled classfiles/bytecode.

    When you override this, you probably also want to override bspCompileClassesPath.

    Definition Classes
    JavaModuleSemanticDbJavaModule
  29. def compileClasspath: T[Agg[api.PathRef]]

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

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

    Definition Classes
    JavaModuleSemanticDbJavaModule
  30. def compileIvyDeps: T[Agg[Dep]]

    Same as ivyDeps, but only present at compile time.

    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

  31. def compileModuleDeps: Seq[JavaModule]

    The compile-only direct dependencies of this module.

  32. final def compileModuleDepsChecked: Seq[JavaModule]

    Same as compileModuleDeps but checked to not contain cycles.

  33. def compileResources: T[Seq[api.PathRef]]

    The folders where the compile time resource files for this module live.

    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.

  34. def compiledClassesAndSemanticDbFiles: define.Target[api.PathRef]
    Definition Classes
    SemanticDbJavaModule
  35. def coursierCacheCustomizer: define.Task[Option[(FileCache[coursier.util.Task]) => FileCache[coursier.util.Task]]]

    Customize the coursier file cache.

    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))
       )
    }
    Definition Classes
    CoursierModule
  36. def defaultCommandName(): String

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

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

    Definition Classes
    JavaModuleTaskModule
  37. def doRunBackground(taskDest: Path, runClasspath: Seq[api.PathRef], zwBackgroundWrapperClasspath: Agg[api.PathRef], forkArgs: Seq[String], forkEnv: Map[String, String], finalMainClass: String, forkWorkingDir: Path, runUseArgsFile: Boolean, backgroundOutputs: Option[(ProcessOutput, ProcessOutput)])(args: String*): (Ctx) => Result[Unit]
    Attributes
    protected
  38. def docJar: T[api.PathRef]

    The documentation jar, containing all the Javadoc/Scaladoc HTML files, for publishing to Maven Central

  39. def docJarUseArgsFile: T[Boolean]

    Control whether docJar-target should use a file to pass command line arguments to the javadoc tool.

    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.

  40. def docResources: T[Seq[api.PathRef]]

    Extra directories to be copied into the documentation.

    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.

    See also

    docSources

  41. def docSources: T[Seq[api.PathRef]]

    Directories to be processed by the API documentation tool.

    Directories to be processed by the API documentation tool.

    Typically includes the source files to generate documentation from.

    See also

    docResources

  42. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  43. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  44. def finalMainClass: T[String]
  45. def finalMainClassOpt: T[Either[String, String]]
  46. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  47. def forkArgs: T[Seq[String]]

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

  48. def forkEnv: T[Map[String, String]]

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

  49. def forkWorkingDir: T[Path]
  50. def generatedSources: T[Seq[api.PathRef]]

    Folders containing source files that are generated rather than hand-written; these files can be generated in this target itself, or can refer to files generated from other targets

  51. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  52. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  53. def ideaCompileOutput: T[PathRef]
    Definition Classes
    GenIdeaModule
  54. def ideaConfigFiles(ideaConfigVersion: Int): define.Task[Seq[IdeaConfigFile]]

    Contribute components to idea config files.

    Contribute components to idea config files.

    Definition Classes
    GenIdeaModule
  55. def ideaJavaModuleFacets(ideaConfigVersion: Int): define.Task[Seq[JavaFacet]]

    Contribute facets to the Java module configuration.

    Contribute facets to the Java module configuration.

    ideaConfigVersion

    The IDEA configuration version in use. Probably 4.

    Definition Classes
    GenIdeaModule
  56. def intellijModulePath: Path
    Definition Classes
    GenIdeaModule
  57. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  58. def ivyDeps: T[Agg[Dep]]

    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

    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

    Definition Classes
    JavaModuleJavaModuleBase
  59. def ivyDepsTree(args: IvyDepsTreeArgs = IvyDepsTreeArgs()): define.Command[Unit]

    Command to print the transitive dependency tree to STDOUT.

  60. def jar: T[api.PathRef]

    A jar containing only this module's resources and compiled classfiles, without those from upstream modules and dependencies

  61. def javacOptions: T[Seq[String]]

    Options to pass to the java compiler

    Options to pass to the java compiler

    Definition Classes
    JavaModuleSemanticDbJavaModule
  62. def javadocOptions: T[Seq[String]]

    Additional options to be used by the javadoc tool.

    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.

  63. def launcher: define.Target[api.PathRef]

    Builds a command-line "launcher" file that can be used to run this module's code, without the Mill process.

    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

  64. def localClasspath: T[Seq[api.PathRef]]

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

  65. def localCompileClasspath: T[Agg[api.PathRef]]

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

  66. def mainClass: T[Option[String]]

    Allows you to specify an explicit main class to use for the run command.

    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

  67. def mandatoryIvyDeps: T[Agg[Dep]]

    Mandatory ivy dependencies that are typically always required and shouldn't be removed by overriding ivyDeps, e.g.

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

  68. def manifest: T[JarManifest]

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

  69. def mapDependencies: define.Task[(coursier.Dependency) => coursier.Dependency]

    Map dependencies before resolving them.

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

    Definition Classes
    CoursierModule
  70. implicit def millModuleBasePath: BasePath
    Definition Classes
    Module
  71. def millModuleDirectChildren: Seq[define.Module]
    Definition Classes
    Module
  72. implicit def millModuleExternal: External
    Definition Classes
    Module
  73. implicit def millModuleSegments: Segments
    Definition Classes
    Module
  74. implicit def millModuleShared: Foreign
    Definition Classes
    Module
  75. def millOuterCtx: Ctx
    Definition Classes
    BaseClass
  76. def millSourcePath: Path
    Definition Classes
    Module
  77. def moduleDeps: Seq[JavaModule]

    The direct dependencies of this module.

    The direct dependencies of this module.

    See also

    moduleDepschecked

  78. final def moduleDepsChecked: Seq[JavaModule]

    Same as moduleDeps but checked to not contain cycles.

  79. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  80. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  81. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  82. def platformSuffix: T[String]

    What platform suffix to use for publishing, e.g.

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

  83. def prepareOffline(all: Flag): define.Command[Unit]

    all

    If true fetches also source dependencies

    Definition Classes
    JavaModuleOfflineSupportModule
  84. def prependShellScript: T[String]

    What shell script to use to launch the executable generated by assembly.

    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

  85. def printDepsTree(inverse: Boolean, additionalDeps: define.Task[Agg[BoundDep]], whatDependsOn: List[JavaOrScalaModule]): define.Task[Unit]

    Task that print the transitive dependency tree to STDOUT.

    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.

    inverse

    Invert the tree representation, so that the root is on the bottom.

    additionalDeps

    Additional dependency to be included into the tree.

    whatDependsOn

    possible list of modules to target in the tree in order to see where a dependency stems from.

    Attributes
    protected
  86. def recursiveModuleDeps: Seq[JavaModule]

    The direct and indirect dependencies of this module

  87. def repositoriesTask: define.Task[Seq[Repository]]

    The repositories used to resolved dependencies with resolveDeps().

    The repositories used to resolved dependencies with resolveDeps().

    Definition Classes
    CoursierModule
  88. def resolutionCustomizer: define.Task[Option[(Resolution) => Resolution]]

    Customize the coursier resolution resolution process.

    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))
      )
    }
    Definition Classes
    CoursierModule
  89. def resolveDeps(deps: define.Task[Agg[BoundDep]], sources: Boolean = false): define.Task[Agg[api.PathRef]]

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

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

    deps

    The dependencies to resolve.

    sources

    If true, resolve source dependencies instead of binary dependencies (JARs).

    returns

    The PathRefs to the resolved files.

    Definition Classes
    CoursierModule
  90. def resolvePublishDependency: define.Task[(Dep) => publish.Dependency]
  91. def resolvedIvyDeps: T[Agg[api.PathRef]]

    Resolved dependencies based on transitiveIvyDeps and transitiveCompileIvyDeps.

  92. def resolvedRunIvyDeps: T[Agg[api.PathRef]]
  93. def resolvedSemanticDbJavaPluginIvyDeps: T[Agg[api.PathRef]]
    Attributes
    protected
    Definition Classes
    SemanticDbJavaModule
  94. def resources: T[Seq[api.PathRef]]

    The folders where the resource files for this module live.

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

  95. def run(args: define.Task[Args] = T.task(Args())): define.Command[Unit]

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

  96. def runBackground(args: String*): define.Command[Unit]

    Runs this module's code in a background process, until it dies or runBackground is used again.

    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

  97. def runBackgroundLogToConsole: Boolean

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

  98. def runClasspath: T[Seq[api.PathRef]]

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

  99. def runIvyDeps: T[Agg[Dep]]

    Additional dependencies, only present at runtime.

    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.

  100. def runLocal(args: define.Task[Args] = T.task(Args())): define.Command[Unit]

    Runs this module's code in-process within an isolated classloader.

    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.

  101. def runMain(mainClass: String, args: String*): define.Command[Unit]

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

  102. def runMainBackground(mainClass: String, args: String*): define.Command[Unit]

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

  103. def runMainLocal(mainClass: String, args: String*): define.Command[Unit]

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

  104. def runUseArgsFile: T[Boolean]

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

  105. def semanticDbData: T[api.PathRef]
    Definition Classes
    SemanticDbJavaModule
  106. def semanticDbEnablePluginScalacOptions: T[Seq[String]]

    Scalac options to activate the compiler plugins.

    Scalac options to activate the compiler plugins.

    Attributes
    protected
    Definition Classes
    SemanticDbJavaModule
  107. def semanticDbJavaVersion: T[String]
    Definition Classes
    SemanticDbJavaModule
  108. def semanticDbPluginClasspath: T[Agg[api.PathRef]]
    Attributes
    protected
    Definition Classes
    SemanticDbJavaModule
  109. def semanticDbPluginIvyDeps: T[Agg[Dep]]
    Attributes
    protected
    Definition Classes
    SemanticDbJavaModule
  110. def semanticDbScalaVersion: T[String]
    Definition Classes
    SemanticDbJavaModule
  111. def semanticDbVersion: T[String]
    Definition Classes
    SemanticDbJavaModule
  112. def showModuleDeps(recursive: Boolean = false): define.Command[Unit]

    Show the module dependencies.

    Show the module dependencies.

    recursive

    If true include all recursive module dependencies, else only show direct dependencies.

  113. def skipIdea: Boolean

    Skip Idea project file generation.

    Skip Idea project file generation.

    Definition Classes
    GenIdeaModule
  114. def sourceJar: T[api.PathRef]

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

  115. def sources: T[Seq[api.PathRef]]

    The folders where the source files for this module live

  116. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  117. def toString(): String
    Definition Classes
    Module → AnyRef → Any
  118. def transitiveCompileClasspath: T[Agg[api.PathRef]]

    The transitive version of compileClasspath

  119. def transitiveCompileIvyDeps: T[Agg[BoundDep]]

    The compile-only transitive ivy dependencies of this module and all it's upstream compile-only modules.

  120. def transitiveIvyDeps: T[Agg[BoundDep]]

    The transitive ivy dependencies of this module and all it's upstream modules.

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

  121. def transitiveLocalClasspath: T[Agg[api.PathRef]]

    The transitive version of localClasspath

  122. def transitiveModuleCompileModuleDeps: Seq[JavaModule]

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

    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

  123. def transitiveModuleDeps: Seq[JavaModule]

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

  124. def unmanagedClasspath: T[Agg[api.PathRef]]

    Additional jars, classfiles or resources to add to the classpath directly from disk rather than being downloaded from Maven Central or other package repositories

  125. def upstreamAssembly: T[api.PathRef]

    Build the assembly for upstream dependencies separate from the current classpath

    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

  126. def upstreamAssemblyClasspath: T[Agg[api.PathRef]]

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

  127. def upstreamCompileOutput: T[Seq[CompilationResult]]

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

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

    Definition Classes
    JavaModuleSemanticDbJavaModule
  128. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  129. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  130. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  131. def zincIncrementalCompilation: T[Boolean]
    Definition Classes
    JavaModuleSemanticDbJavaModule
  132. def zincReportCachedProblems: T[Boolean]

    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.

    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.

    Definition Classes
    JavaModuleSemanticDbJavaModule
  133. def zincWorker: ModuleRef[ZincWorkerModule]
    Definition Classes
    JavaModuleSemanticDbJavaModule

Deprecated Value Members

  1. def resolveCoursierDependency: define.Task[(Dep) => coursier.Dependency]
    Definition Classes
    CoursierModule
    Annotations
    @deprecated
    Deprecated

    (Since version Mill after 0.11.0-M0) To be replaced by bindDependency

Inherited from JavaModuleBase

Inherited from SemanticDbJavaModule

Inherited from BspModule

Inherited from OfflineSupportModule

Inherited from CoursierModule

Inherited from GenIdeaModule

Inherited from define.TaskModule

Inherited from define.Module

Inherited from BaseClass

Inherited from Cacher

Inherited from AnyRef

Inherited from Any

Ungrouped