-
-
Notifications
You must be signed in to change notification settings - Fork 372
/
Copy pathreadme.adoc
2727 lines (1953 loc) · 108 KB
/
readme.adoc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
= image:docs/logo.svg[Mill Logo] Mill
:idprefix:
:idseparator: -
:link-github: https://github.com/com-lihaoyi/mill
:link-current-doc-site: https://mill-build.org
:link-mill-moduledefs: https://github.com/com-lihaoyi/mill-moduledefs
:example-scala-version: 3.3.4
:toc:
:toc-placement: preamble
ifndef::env-github[]
:icons: font
endif::[]
ifdef::env-github[]
:caution-caption: :fire:
:important-caption: :exclamation:
:note-caption: :paperclip:
:tip-caption: :bulb:
:warning-caption: :warning:
endif::[]
{link-github}/actions/workflows/run-tests.yml[image:{link-github}/actions/workflows/run-tests.yml/badge.svg[Build and Release]]
https://index.scala-lang.org/com-lihaoyi/mill/mill-main[image:https://index.scala-lang.org/com-lihaoyi/mill/mill-main/latest.svg[Mill]]
https://www.patreon.com/lihaoyi[image:https://img.shields.io/badge/patreon-sponsor-ff69b4.svg[Patreon]]
Mill is a fast JVM build tool that supports Java and Scala. Mill aims to make your
project’s build process performant, maintainable, and flexible.
== Documentation
If you want to use Mill in your own projects, check out our documentation:
* {link-current-doc-site}[Documentation]
Here is some quick example, so that you can imagine how it looks:
[source,scala,subs="verbatim,attributes"]
----
import mill._, scalalib._
object foo extends ScalaModule {
def scalaVersion = "{example-scala-version}"
}
object bar extends ScalaModule {
def moduleDeps = Seq(foo)
def scalaVersion = "{example-scala-version}"
}
----
If you use Mill and like it, you will probably enjoy the following book by the Author:
* https://www.handsonscala.com/[_Hands-on Scala Programming_]
The remainder of this readme is developer-documentation targeted at people who wish to work
on Mill's own codebase. The developer docs assume you have read through the user-facing
documentation linked above. It's also worth spending a few minutes reading the following
blog posts to get a sense of Mill's design & motivation:
* http://www.lihaoyi.com/post/SowhatswrongwithSBT.html["So, what's wrong with SBT?"]
* http://www.lihaoyi.com/post/BuildToolsasPureFunctionalPrograms.html[Build Tools as Pure Functional Programs]
* http://www.lihaoyi.com/post/MillBetterScalaBuilds.html[Mill: Better Scala Builds]
Mill is profiled using the
https://www.ej-technologies.com/products/jprofiler/overview.html[JProfiler Java Profiler], by courtesy of EJ Technologies.
Mill is built using Mill.
To begin, you just need a JVM installed, and the
`./mill` script will be sufficient to bootstrap the project.
== IntelliJ Setup
If you are using IntelliJ IDEA to edit Mill's Scala code, IntelliJ's built in BSP support should
be sufficient to load the Mill project, but you need to set up the file association from
`*.mill` as Scala source files manually in the following settings:
* `Settings` / `Editor` / `File Types` / `Scala`, add the pattern `*.mill`
== Manual & Automated Testing
The following table contains the main ways you can test the code in
`com-lihaoyi/mill`, via manual testing or automated tests:
|===
| Config | Automated Testing | Manual Testing | Manual Testing CI
| In-Process Tests | `main.__.test`, `scalalib.test`, `contrib.buildinfo.test`, etc. | |
| Sub-Process w/o packaging/publishing| `example.\\__.local`, `integration.__.local` | `dist.run` | `test-mill-dev.sh`
| Sub-Process w/ packaging/publishing | `example.\\__.server`, `integration.__.server` | `dist.assembly` | `test-mill-release.sh`
| Bootstrapping: Building Mill with your current checkout of Mill | | `dist.installLocal` | `test-mill-bootstrap.sh`
|===
In general, `println` or `pprint.log` should work in most places and be sufficient for
instrumenting and debugging the Mill codebase. In the occasional spot where `println`
doesn't work you can use `mill.main.client.DebugLog.println` which writes to a file
`~/mill-debug-log.txt` in your home folder. `DebugLog` is useful for scenarios like
debugging Mill's terminal UI (where `println` would mess things up) or subprocesses
(where stdout/stderr may get captured or used and cannot be used to display your own
debug statements).
=== In-Process Tests
In-process tests live in the `.test` sub-modules of the various Mill modules.
These range from tiny unit tests, to larger integration tests that instantiate a
`mill.testkit.BaseModule` in-process and a `UnitTester` to evaluate tasks on it.
Most "core" tests live in `main.__test`; these should run almost instantly, and cover
most of Mill's functionality that is not specific to Scala/Scala.js/etc..
Tests specific to Scala/Scala.js/Scala-Native live in
`scalalib.test`/`scalajslib.test`/`scalanativelib.test` respectively, and take a lot longer
to run because running them involves actually compiling Scala code.
The various `contrib` modules also have tests in this style, e.g.
`contrib.buildinfo.test`
Note that the in-memory tests compile the `BaseModule` together with the test suite,
and do not exercise the Mill script-file bootstrapping, transformation, and compilation process.
=== Sub-Process Tests *without* Packaging/Publishing
`example.\\__.local` and `integration.__.local` tests run Mill end-to-end in a subprocess,
but *without* the expensive/slow steps of packaging the core packages into an assembly jar
and publishing the remaining packages to
`~/.ivy2/local`.
You can reproduce these tests manually using
`./mill dist.run <test-folder-path> <command>`.
`example` tests are written in a single `build.mill` file, with the test commands written
in a comment with a bash-like syntax together with the build code and comments that explain
the example.
These serve three purposes:
1. Basic smoke-tests to make sure the functionality works at all, without covering every
edge case
2. User-facing documentation, with the test cases, test commands, and explanatory comments
included in the Mill documentation site
3. Example repositories, that Mill users can download to bootstrap their own projects
The `integration` tests are similar to `example` tests and share most of their test
infrastructure, but with differences:
1. `integration` tests are meant to test features more thoroughly then
`example` tests, covering more and deeper edge cases even at the expense of readability
2. `integration` tests are written using a Scala test suite extending
`IntegrationTestSuite`, giving more flexibility at the expense of readability
You can reproduce any of the tests manually using `dist.run`, e.g.
**Automated Test**
[source,bash]
----
./mill "example.javalib.basic[1-simple].local"
----
**Manual Test**
[source,bash]
----
./mill dist.run example/javalib/basic/1-simple foo.run --text hello
----
**Manual Test using Launcher Script**
[source,bash]
----
./mill dist.launcher && (cd example/javalib/basic/1-simple && ../../../../out/dist/launcher.dest/run foo.run --text hello)
----
=== Sub-Process Tests *with* Packaging/Publishing
`example.\\__.server`, `integration.__.server`, `example.\\__.fork` and
`integration.__.fork` cover the same test cases as the `.local` tests described above, but
they perform packaging of the Mill core modules into an assembly jar, and publish the
remaining modules to `~/.ivy2/local`.
This results in a more realistic test environment, but at the cost of taking tens-of-seconds
more to run a test after making a code change.
You can reproduce these tests manually using `dist.assembly`:
[source,bash]
----
./mill dist.assembly && (cd example/basic/1-simple && ../../../out/dist/assembly.dest/mill run --text hello)
----
There are two flavors of these tests:
1. `.server` test run the test cases with the default configuration, so consecutive commands
run in the same long-lived background server process
2. `.fork` test run the test cases with `--no-server`, meaning each command runs in a newly
spawned Mill process
In general you should spend most of your time working with the `.local` version of the
`example` and `integration` tests to save time, and only run `.fork`
or `.server` once `.local` is passing.
=== Bootstrapping: Building Mill with your current checkout of Mill
To test bootstrapping of Mill's own Mill build using a version of Mill built from your checkout, you can run
[source,bash]
----
./mill dist.installLocal
ci/patch-mill-bootstrap.sh
----
This creates a standalone assembly at `target/mill-release` you can use, which references jars
published locally in your `~/.ivy2/local` cache, and applies any necessary patches to
`build.mill` to deal with changes in Mill between the version specified in `.config/mill-version`
that is normally used to build Mill and the `HEAD` version your assembly was created from.
You can then use this standalone assembly to build & re-build your current Mill checkout without
worrying about stomping over compiled code that the assembly is using.
You can also use `./mill dist.installLocalCache` to provide a "stable" version of Mill that
can be used locally in bootstrap scripts.
This assembly is design to work on bash, bash-like shells and Windows Cmd.
If you have another default shell like zsh or fish, you probably need to invoke it with
`sh ~/mill-release` or prepend the file with a proper shebang.
If you want to install into a different location or a different Ivy repository, you can set its optional parameters.
.Install into `/tmp`
[source,bash]
----
$ ./mill dist.installLocal --binFile /tmp/mill --ivyRepo /tmp/millRepo
...
Published 44 modules and installed /tmp/mill
----
=== Testing Documentation Changes
For testing documentation changes locally, you can generate documentation for the current checkout via
[source,bash]
----
$ ./mill docs.fastPages
----
To generate documentation for both the current checkout and earlier versions, you can use
[source,bash]
----
$ ./mill docs.localPages
----
=== Troubleshooting
In case of troubles with caching and/or incremental compilation, you can always restart from scratch removing the `out` directory:
[source,bash]
----
rm -rf out/
----
=== Autofix and Autoformatting
To run all autofixes and autoformatters:
```bash
./mill __.fix + mill.javalib.palantirformat.PalantirFormatModule/ + mill.scalalib.scalafmt.ScalafmtModule/ + mill.kotlinlib.ktlint.KtlintModule/
```
== Project Layout
The Mill project is organized roughly as follows:
=== Core modules that are included in the main assembly
* `runner`, `main.*`, `scalalib`, `scalajslib`, `scalanativelib`.
These are general lightweight and dependency-free: mostly configuration & wiring of a Mill
build and without the heavy lifting.
Heavy lifting is delegated to the worker modules (described below), which the core modules
resolve from Maven Central (or from the local filesystem in dev) and load into isolated
classloaders.
=== Worker modules that are resolved from Maven Central
* `scalalib.worker`, `scalajslib.worker[0.6]`, `scalajslib.worker[1.0]`
These modules are where the heavy-lifting happens, and include heavy dependencies like the
Scala compiler, Scala.js optimizer, etc.. Rather than being bundled in the main assembly &
classpath, these are resolved separately from Maven Central (or from the local filesystem
in dev) and kept in isolated classloaders.
This allows a single Mill build to use multiple versions of e.g. the Scala.js optimizer
without classpath conflicts.
=== Contrib modules
* `contrib/bloop/`, `contrib/flyway/`, `contrib/scoverage/`, etc.
These are modules that help integrate Mill with the wide variety of different tools and
utilities available in the JVM ecosystem.
These modules are not as stringently reviewed as the main Mill core/worker codebase, and
are primarily maintained by their individual contributors.
These are maintained as part of the primary Mill Github repo for easy testing/updating as
the core Mill APIs evolve, ensuring that they are always tested and passing against the
corresponding version of Mill.
== Compatibility & Stability
Mill maintains backward binary compatibility for each major version (`major.minor.point`),
enforced with Mima, for the following packages:
- `mill.api`
- `mill.util`
- `mill.define`
- `mill.eval`
- `mill.resolve`
- `mill.scalalib`
- `mill.scalajslib`
- `mill.scalanativelib`
Other packages like `mill.runner`, `mill.bsp`, etc. are on the classpath but offer no
compatibility guarantees.
Currently, Mill does not offer compatibility guarantees for `mill.contrib`
packages, although they tend to evolve slowly.
This may change over time as these packages mature over time.
== Project Maintenance
=== Pull Requests
* Changes to the main branch need a pull request.
Exceptions are preparation commits for releases, which are meant to be pushed with tags in one go
* Merged pull request (and closed issues) need to be assigned to a Milestone
* Pull requests are typically merged via "Squash and merge", so we get a linear and useful history
* Larger pull request, where it makes sense to keep single commits, or with multiple authors may be committed via merge commits.
=== Commit Messages
* The title should be meaningful and may contain the pull request number in parentheses (typically automatically generated on GitHub)
* The description should contain additional required details, which typically reflect the content of the first PR comment
* A full link to the pull request should be added via a line: `Pull request: <link>`
* If the PR has multiple authors but is merged as merge commit, those authors should be included via a line for each co-author: `Co-authored-by: <author>`
* If the message contains links to other issues or pull requests, you should use full URLs to reference them
// tag::changelog[]
== Changelog
ifndef::link-github[]
:link-github: https://github.com/com-lihaoyi/mill
endif::[]
:link-compare: {link-github}/compare
:link-pr: {link-github}/pull
:link-issue: {link-github}/issues
:link-milestone: {link-github}/milestone
// find-replace-regex: https://github.com/com-lihaoyi/mill/pull/(\d*) -> {link-pr}/$1[#$1]
[#0-12-3]
=== 0.12.3 - 2024-11-24
:version: 0.12.3
:milestone-name: 0.12.3
:milestone: 106
:prev-version: 0.12.2
* Set context classloader during Mill evaluation {link-pr}/3940[#3940]
* Extended `mill init` to support importing an existing Maven project {link-pr}/3756[#3756]
* Avoid running subsequent meta-level builds after reaching the desired meta-level in MillBuildBootstrap {link-pr}/3960[#3960]
* Improvements to `KtlintModule` {link-pr}/3961[#3961] {link-pr}/3966[#3966]
* Fixes for `runBackground` mutex and log management {link-pr}/3971[#3971]
* Added support for Revapi {link-pr}/3974[#3974]
* Fix redundant logging in junit5 test runner {link-pr}/3983[#3983]
* align SonatypeCentralPublishModule with SonatypePublisher {link-pr}/3987[#3987]
* Make JVM version configurable per-module {link-pr}/3716[#3716]
* Overhaul worker concurrency helpers with `mill.api.CacheFactory` {link-pr}/4001[#4001]
* Optimize startup time using TCP sockets instead of junixsocket and `tput` instead of jline {link-pr}/4009[#4009]
* Improvements to TUI build prompt https://github.com/com-lihaoyi/mill/pull/3933[#3933] https://github.com/com-lihaoyi/mill/pull/4014[#4014]
* Lots of improvements to documentation, including a new https://github.com/com-lihaoyi/mill/pull/3965[Kotlin Spring-Boot Example #3965],
a new page https://github.com/com-lihaoyi/mill/pull/3990[How Fast Does Java Compile? #3990], and
https://github.com/com-lihaoyi/mill/pull/3938[Stable Links To Older Doc-site Versions #3938]
[#0-12-2]
=== 0.12.2 - 2024-11-11
:version: 0.12.2
:milestone-name: 0.12.2
:milestone: 105
:prev-version: 0.12.1
_Changes since {prev-version}:_
* Show correct build file name in progress prompt {link-pr}/3847[#3847]
* Fix target name when reporting cycles in `runModuleDeps` {link-pr}/3860[#3860]
* Properly escape imported submodule names when the name is a Scala identifier {link-pr}/3865[#3865]
* Report an error when module dependency cycles are detected {link-pr}/3878[#3878]
* Drop incremental compilation state for Mill modules when version changes to try and mitigate cache invalidation issues {link-pr}/3884[#3884]
* Share profile loggers between nested evaluations to avoid ensure commands like `show` now have a proper profile {link-pr}/3885[#3885]
* Add `nativeMultithreading` flag in ScalaNativeModule {link-pr}/3896[#3896]
* Add nice error when non-exclusive task depends on exclusive task {link-pr}/3887[#3887]
* Filter out anonymous classes during test discovery to mitigate spurious test reports {link-pr}/3911[#3911]
* Fix `MavenTests` deprecation message {link-pr}/3915[#3915]
* Improve `inspect` command to show more detailed metadata on modules and tasks {link-pr}/3916[#3916]
* Fix prompt updating logic to ensure the timestamp updates while tasks are running {link-pr}/3933[#3933]
* Fix scoverage report generation for Scala 3 {link-pr}/3936[#3936]
* Tons of documentation improvements: autoformatted all https://github.com/com-lihaoyi/mill/pull/3919[Java]
and https://github.com/com-lihaoyi/mill/pull/3903[Scala] example files,
[Scala-Native example builds]https://github.com/com-lihaoyi/mill/pull/3657,
https://github.com/com-lihaoyi/mill/pull/3897[Scala-JS WASM example build],
https://github.com/com-lihaoyi/mill/pull/3918[Re-run Maven comparison using proper flags]
added https://mill-build.org/mill/comparisons/why-mill.html[Why Use Mill?] and
https://mill-build.org/mill/comparisons/unique.html[What Makes Mill Unique?] Sections
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-12-1]
=== 0.12.1 - 2024-10-27
:version: 0.12.1
:milestone-name: 0.12.1
:milestone: 104
:prev-version: 0.12.0
_Changes since {prev-version}:_
* Fix updating of prompt to match terminal width in client-server mode {link-pr}/3833[#3833]
* Allow `.mill-jvm-opts` to interpolate environment variables, add `.mill-opts` {link-pr}/3841[#3841]
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-12-0]
=== 0.12.0 - 2024-10-23
The Mill 0.12.0 release focuses on improving the scalability of Mill builds: in terms
of performance, code organization, adherence to best practices, and community.
Major changes:
1. Mill now runs tasks parallel by default, rather than opt-in. This includes a
new parallel-friendly terminal UI, https://mill-build.org/mill/Mill_Sandboxing.html[task
and test sandboxing] to guard against race conditions,
xref:javalib/testing.adoc#_test_grouping[parallelization of test suites],
and other measures optimizing for parallel builds
2. Mill now uses `build.mill` rather than `build.sc` as the primary file extension, to avoid
confusion with Scala-CLI or Ammonite scripts, and the `T`/`T.worker`/`T.input` syntax
has been deprecated in favor of `Task`/`Task.Worker`/`T.Input` for a more idiomatic style
3. Mill now supports for https://mill-build.org/mill/Structuring_Large_Builds.html[Modularizing Large Builds]
into multiple `package.mill` files, to help support large codebases and incremental compilation
of the build files.
4. Mill now provides official support for https://mill-build.org/mill/Writing_Mill_Plugins.html[Writing Mill Plugins],
with tested workflows and an official testkit to help you write and publish your own Mill
plugins for others to use
5. Mill now supports other JVM langauges: https://mill-build.org/mill/javalib/intro.html[Java],
experimental support for https://mill-build.org/mill/kotlinlib/intro.html[Kotlin/KotlinJs],
and https://mill-build.org/mill/android/kotlin.html[even-more-experimental support for Android].
This includes IDE integrations, tooling integrations (docs, autoformatters, linters, testing
frameworks, etc.)
6. The Mill doc-site at https://mill-build.org/ has undergone a massive overhaul.
New comparisons with other build tools of (https://mill-build.org/mill/comparisons/maven.html[Maven],
https://mill-build.org/mill/comparisons/gradle.html[Gradle],
https://mill-build.org/mill/comparisons/sbt.html[SBT]), documentation for
https://mill-build.org/mill/extending/new-language.html[adding new language toolchains]
and https://mill-build.org/mill/extending/running-jvm-code.html[running dynamic JVM code],
and re-organized the pages for Scala/Java/Kotlin by-use-case to make them more navigable
For a more detailed view of Mill changes since 0.11.12, along with migration instructions,
see the sections below on:
* <<0-12-0-RC1>>
* <<0-12-0-RC2>>
* <<0-12-0-RC3>>
* <<0-12-0-since-rc2>>
0.12.x is binary compatible with 0.11.x, and so Mill plugins published for Mill 0.11.x can
continue to be used without updating them. Although binary compatible, Mill 0.12.x does
have breaking changes listed below with instructions provided on how to either disable the
breaking change with a flag or adjust your code to accommodate it. You should download the
latest version of the https://github.com/com-lihaoyi/mill/blob/main/mill[Mill Bootstrap Script]
if you are upgrading from a prior version.
If you need help upgrading from 0.11.x or hit any issues, please visit the
https://discord.com/invite/xJCYRVMS[#mill Discord Channel] or
https://github.com/com-lihaoyi/mill/discussions/3349[0.12.x Github Discussion Thread]. We'd
love to hear from you on your experience with Mill in general and Mil 0.12.x in particular
* *Example Upgrade PRs*
** The following PRs are example upgrades of Mill from 0.11.x to 0.12.0-RC1 for various
projects in the `com.lihaoyi` ecosystem.
*** Trivial upgrades that just needed to bump a version: https://github.com/com-lihaoyi/geny/pull/87 ,
https://github.com/com-lihaoyi/sourcecode/pull/175, https://github.com/com-lihaoyi/fansi/pull/107,
https://github.com/com-lihaoyi/PPrint/pull/141, https://github.com/com-lihaoyi/mainargs/pull/159/files,
https://github.com/com-lihaoyi/fastparse/pull/319, https://github.com/com-lihaoyi/scalatags/pull/284
https://github.com/com-lihaoyi/castor/pull/64, https://github.com/com-lihaoyi/utest/pull/351
*** Less trivial upgrades, needing to make use of `MILL_TEST_RESOURCE_DIR` or other explicit path references to
be compatible with test sandboxing: https://github.com/com-lihaoyi/requests-scala/pull/174,
https://github.com/com-lihaoyi/upickle/pull/627, https://github.com/com-lihaoyi/os-lib/pull/300,
https://github.com/com-lihaoyi/scalasql/pull/30, https://github.com/com-lihaoyi/Ammonite/pull/1575
*** More involved upgrades: https://github.com/com-lihaoyi/cask/pull/143
[#0-12-0-since-rc2]
==== 0.12.0 Changes since RC3
* Mill now takes a lock on the `out/` folder whenver evaluating it to avoid race conditions on disk.
{link-pr}/3599[#3599]. Pass in `--no-build-lock` to disable it at your own risk
* Update Zinc to 0.10.3 to fix issues with over-compilation {link-pr}/3748[#3748]
* `runIvyDeps` is now transitive, as is the newly-introduced `runModuleDeps`,
to try and match the semantics of runtime deps in Maven{link-pr}/3774[#3774]
[#0-12-0-RC3]
==== 0.12.0-RC3 - 2024-10-04
Changes since 0.12.0-RC2
* `-j`/`--jobs` now allows computed values of the form `-j 0.5C` (half as many jobs as cores) or
`-j C-2` (two less jobs than cores) to allow for automatic scaling based on the number of cores available
{link-pr}/3554[#3554]
* Fix `testOnly` handling of ScalaTest tagged tests {link-pr}/3557[#3557]
* Make `./mill` without any arguments point you towards --help, flesh out --help into a cheat sheet {link-pr}/3556[#3556]
* Use `Task` instead of `T` when constructing targets and other tasks {link-pr}/3565[#3565]. The new syntax
(given below) is intended to be more idiomatic Scala and less idiosyncratic. The old syntax will continue
to work for backwards compatibility, but using the new syntax is recommended
** `T {...}` -> `Task {...}`
** `T.command {...}` -> `Task.Command {...}`
** `T.input {...}` -> `Task.Input {...}`
** `T.source {...}` -> `Task.Source {...}`
** `T.sources {...}` -> `Task.Sources {...}`
** `T.persistent {...}` -> `Task(persistent = true) {...}`
** `T.task {...}` -> `Task.Anon {...}`
* Introduced `Task.Command(exclusive = true)` to allow explicit annotation of which
commands need to run without parallelism, allowing `.test` and other commands
to run parallel by default {link-pr}/3617[#3617]
* Lots of added docs for Building Kotlin with Mill:
** Kotlin Build Examples and Linting {link-pr}/3555[#3555], with KtLint and Detekt support
** Kotlin Module Configuration {link-pr}/3585[#3585]
** Publishing and Testing Kotlin with Mill {link-pr}/3589[#3589]
** Using Mill to build a Ktor web server {link-pr}/3621[#3621]
* Additional support for Kotlin tools and frameworks
** KtFmt support {link-pr}/3620[#3620]
** Kover support {link-pr}/3624[#3624]
* Show Worker tasks in `resolve`/`show`/`inspect` {link-pr}/3580[#3580]
* `mill clean` now terminates Worker tasks {link-pr}/3579[#3579]
* Overhaul of the terminal "ticker" UI for displaying task progress to better support
parallel builds {link-pr}/3577[#3577]
** Mill now shows all active tasks and their duration at the bottom of your terminal
** Stream task logs are now prefixed with the task index on the left and the task
name above, so you can attribute each line of logs to the task that generated it
```
...
[3861/4712] main.client.publishLocalCached
[3861] Publishing Artifact(com.lihaoyi,mill-main-client,0.12.0-RC2-67-a566d8-DIRTY875bcbb1) to ivy repo /Users/lihaoyi/.ivy2/local
[3868/4712] runner.client.publishLocalCached
[3868] Publishing Artifact(com.lihaoyi,mill-runner-client,0.12.0-RC2-67-a566d8-DIRTY875bcbb1) to ivy repo /Users/lihaoyi/.ivy2/local
[3869/4712] ======================================= installLocalCache ============================================== 4s
[3676] scalajslib.worker-api.docJar 1s
[3688] scalanativelib.worker-api.docJar 1s
[3706] contrib.playlib.worker[2.9].docJar 1s
[3707] contrib.playlib.worker[2.6].docJar 1s
... and 3 more threads
```
* Add API for tasks to spawn concurrent and parallel futures via `Task.fork.{async,await}` {link-pr}/3478[#3478]
* Allow large test modules with many classes to be broken up to use multiple concurrent JVMs
by overriding `def testForkGrouping` {link-pr}/3478[#3478]
* Use coursier thread pool to run coursier-related tasks to avoid deadlocks {link-pr}/3614[#3614]
* `inspect` now shows useful information when used on modules, not just tasks {link-pr}/3532[#3532]
```
$ ./mill inspect dist0
dist0(build.mill:745)
Version of [[dist]] meant for local integration testing within the Mill
repo. Looks mostly the same as [[dist]], except it does not have a reference
to itself in its [[testTransitiveDeps]], to avoid a circular dependency.
Inherited Modules: MillPublishJavaModule
Module Dependencies: runner, idea
Default Task: dist0.run
Tasks: dist0.fix, dist0.testTransitiveDeps
```
* `mill init` now supports creating a project based on examples from Mill's documentation {link-pr}/3583[#3583],
and unpacks the example into the current folder rather than a subfolder {link-pr}/3626[#3626]
* `MILL_TEST_RESOURCE_FOLDER` has been renamed to `MILL_TEST_RESOURCE_DIR` for consistency with other
environment variable names {link-pr}/3637[#3637]
[#0-12-0-RC2]
==== 0.12.0-RC2 - 2024-09-16
Changes since 0.12.0-RC1
* Support `exclude` attribute in `Dep` parser. You can give exclusions with `;exclude=org:name`
or `;exclude=org:*` or `;exclude=*:name` {link-pr}/3492[#3492]
* Fix `ScalaModule#console` by properly inheriting streams {link-pr}/3500[#3500]
* Adjust codegen to allow custom ``mainargs.TokensReader``s, and include a
`mainargs.TokensReader[os.Path]` by default for convenience {link-pr}/3504[#3504]
* Update to https://github.com/com-lihaoyi/os-lib?tab=readme-ov-file#0-10-7[OS-Lib 0.10.7] to
allow concise multi-segment sub-paths; you can now write `os.pwd / "foo/bar/qux"` rather than
`os.pwd / "foo" / "bar" / "qux"`
* Add `JavaModule.mandatoryJavacOptions`. Those are not propagated to the inner test
traits intentionally, since those options are typically configured by other means,
e.g. dedicated targets. {link-pr}/3503[#3503]
* Add plugins to run Checkstyle and generate reports {link-pr}/3516[#3516]
* Simplified ``PublishModule``'s publishing setup via {link-pr}/3523[#3523]. You can now
run `mill mill.scalalib.PublishModule/` with the proper environment variables (below) and
it should do the right thing by default
** Prefix all environment variables with `MILL_`:
`MILL_SONATYPE_USERNAME`, `MILL_SONATYPE_PASSWORD`,
`MILL_PGP_SECRET_BASE64`, `MILL_PGP_PASSPHRASE` to try and add some
rudimentary ownership and namespacing
* Allow external modules to have a `defaultCommandName` {link-pr}/3545[#3545]. This has
been applied to `ScalafmtModule` and `PublishModule`, so you can
now autoformat your code via `mill mill.scalalib.ScalafmtModule/` and publish it via
`mill mill.scalalib.PublishModule/` without needing the `/reformatAll __.sources`
or `/publishAll __.publishArtifacts` suffix
* Integrated Kotlin integration as a first partly module and add example documentation
{link-pr}/3514[#3514]. This is still pretty spartan, but we expect to flesh it out over time
* Move `.mill.sc` alternate file extension to `.mill.scala` {link-pr}/3521[#3521]
[#0-12-0-RC1]
==== 0.12.0-RC1 - 2024-09-09
* *Breaking Changes*
** Build file overhaul: Mill's build file management has been overhauled to better support
large projects. See https://mill-build.org/mill/Structuring_Large_Builds.html[Structuring Large Builds]
for details
*** Mill now uses `.mill` as its file extension, with some semantic changes
from the old `.sc` files to allow better IDE support. The `.sc` extension is still supported
and its semantics are largely unchanged the ease the migration, but you should convert your Mill
configs to `.mill` files to benefit from Mill's improved IDE experience going forward.
*** The `build.sc` file has been renamed `build.mill` to prevent confusion with Ammonite/Scala-CLI scripts,
and all associated `.sc` files have been renamed to `.mill`.
**** Until IntelliJ-Scala adds support for `.mill` files built in, you can add it yourself via
`Settings / Editor / File Types / Scala` and add the pattern `*.mill`
*** All `.mill` files must have a `package` declaration,
with `package build` for `.mill` files in the root folder and `package build.foo.bar` for `.mill` files in `foo/bar/`.
**** The package declaration remains optional for legacy `.sc` files
*** Only `foo.mill` files in folders directly containing a `build.mill` or `package.mill` can
be imported via `import $file`.
**** You need to create empty `package.mill` files in any folder containing scripts if they are not already
adjacent to your `build.mill` in the root folder
**** `foo.sc` files can continue to be imported from arbitrary paths, to ease in the migration
*** Builds can now be modularized into per-folder definitions by defining `package.mill` files in subfolders
{link-pr}/3213[#3213]. You can no longer define targets and modules in arbitrary `foo.sc` files
**** All target and module definitions must be moved into `package.mill` files in each folder.
*** `$file` references in `.mill` files are now absolute from the project root, and thus `.^` to
refer to parent package is no longer supported, for consistency with other programming environments
**** `$file` references in old `.sc` files are unchanged and continue being relative, preserving the
current behavior.
** ``RootModule``s can only be named `package`, e.g. `object foo extends RootModule` must now be
named ``object `package` extends RootModule``.
*** If you have an existing `RootModule`, you need to rename it ``object `package` extends RootModule``
** Turn on parallelism for task evaluation by default, except for commands
which always run serially at the end {link-pr}/3265[#3265]
*** This can be disabled by passing `--jobs 1`
** Mill uses empty sandbox folders as the working directory for running its own code and
{link-pr}/3367[#3367] and test suites {link-pr}/3347[#3347], to avoid accidental interference
between tasks and tests due to parallelism. See https://mill-build.org/mill/Mill_Sandboxing.html[Mill Sandboxing]
for details
*** This can be disabled by adding `def testSandboxWorkingDir = false` in your test module
** Mill commands now require arguments to be passed named via `./mill mycommand --key value`, rather than
allowing just `./mill mycommand value`. {link-pr}/3431[#3431].
*** You can pass in
`--allow-positional-command-args` to fall back to the old behavior, or use `@mainargs.arg(positional = true)`
on individual parameters
** Dropped support for Java 8, Scala 2.11.x/3.1.x, and Scala-Native 0.4.x, following suit with the rest of the
com-lihaoyi ecosystem. We now expect a minimum of Java 11, Scala 2.12.x/3.2.x, and Scala-Native 0.5.x
** `--disable-callgraph-invalidation` is no longer supported. The flag is still accepted but is
now a no-op.
* *Other Changes*
** Overhaul the Mill client-server protocol to improve robustness
{link-pr}/3363[#3363] {link-pr}/3366[#3366] {link-pr}/3368[#3368] {link-pr}/3370[#3370]
** Mill now has explicitly supported workflows for third-party plugin authors, and
publishes unit, integration, and example test fixtures for writing plugins as `mill-testkit`
{link-pr}/3398[#3398] for downstream plugin authors to use in testing their own Mill extensions.
*** See https://mill-build.org/mill/Writing_Mill_Plugins.html[Writing Mill Plugins] for more details.
*** `mill-testkit` is experimental and does not provide the same stability or binary-compatibility
guarantees as the rest of Mill. Nevertheless, if you are writing Mill plugins, please try it out
and let us know what you think!
** Bump default Sonatype Maven Central publishing timeouts to 10 minutes to avoid
timeouts due to slowness https://github.com/com-lihaoyi/mill/commit/b4c9386b0233fab53a312426715e226e4a7f6302
** Importing Mill projects into IntelliJ via BSP now properly marks the `out/`, `.idea/`, and `.bsp/` folders
as excluded {link-pr}/3329[#3329]
** Optimizations to Mill evaluation logic to reduce fixed overhead of running Mill
on large projects {link-pr}/3388[#3388]
** Improvements to `visualize` and `visualizePlan` such that they no longer need to be
prefixed with `show` and no longer need a separate `graphviz`/`dot` install on Mac-OSX
{link-pr}/3438[#3438]
[#0-11-13]
=== 0.11.13 - 2024-01-14
:version: 0.11.13
:milestone-name: 0.11.13
:milestone: 100
:prev-version: 0.11.12
_Changes since {prev-version}:_
* Security Fix: Update protobuf-java to 3.25.5 {link-pr}/3639[#3639]
* Backport: Fixed property handling when using `--define`/`-D` from the Mill CLI. {link-pr}/3795[#3795]
* Backport: GenIdea: Handle failure when evaluating module sources/resources {link-pr}/3755[#3755]
* Update asm from 9.7 to 9.7.1 for Java 24 support {link-pr}/3745[#3745]
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-11-12]
=== 0.11.12 - 2024-08-20
:version: 0.11.12
:milestone-name: 0.11.12
:milestone: 99
:prev-version: 0.11.11
_Changes since {prev-version}:_
* Bump uTest to 0.8.4 {link-pr}/3340[#3340]
* Manage TestModule dependencies via `build.sc` {link-pr}/3320[#3320]
* Fix the warning not being printed when -i/--interactive/--no-server/--bsp are not the first argument {link-pr}/3346[#3346]
* GenIdea: Make Scala SDK specific for JS / Native {link-pr}/3348[#3348]
* CI: Adapt CI for 0.11.x branch {link-pr}/3350[#3350]
* GenIdea: unroll module dependencies {link-pr}/3358[#3358]
* Print pretty error message when Result.Failure is thrown {link-pr}/3393[#3393]
* Avoid spurious deprecation warnings in generated code {link-pr}/3400[#3400]
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-11-11]
=== 0.11.11 - 2024-08-05
:version: 0.11.11
:milestone-name: 0.11.11
:milestone: 98
:prev-version: 0.11.10
*_We initially tagged `0.11.11` on 2024-11-31 but never published the released due to technical issues. On 2024-08-05 we re-tagged and published `0.11.11`._*
_Changes since {prev-version}:_
* Workaround issue in Sonatype which started failing on double slashes in URLs
(even though they previously worked) https://github.com/com-lihaoyi/mill/commit/a293b46e80e37572bae46ef6225f41f547a5b238[Link]
* Overhaul of the documentation site at https://mill-build.org
* New Java- and Scala-specific sections on the documentation, with more detailed
comparisons to existing build tools
* Added graphviz diagrams throughout to help the user in visualizing the concepts involved
* Update versions of JUnit sbt-test-interface libraries that Mill uses
{link-pr}/3296[#3296]
* Make it simpler to resolve dependencies in custom tasks via `defaultResolver().resolveDeps`
{link-pr}/3330[#3330]
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-11-10]
=== 0.11.10 - 2024-07-23
:version: 0.11.10
:milestone-name: 0.11.10
:milestone: 95
:prev-version: 0.11.9
_Changes since {prev-version}:_
__Fixes and Improvements__
* Improvements in Java docs and user experience {link-pr}/3278[#3278]
* Automatically pump os.proc streams when SystemStreams are redirected {link-pr}/3275[#3275]
* Fix resolution of children of override lazy val modules {link-pr}/3270[#3270]
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-11-9]
=== 0.11.9 - 2024-07-18
:version: 0.11.9
:milestone-name: 0.11.9
:milestone: 94
:prev-version: 0.11.8
_Changes since {prev-version}:_
__New features__
* First class support for Java projects {link-pr}/3261[#3261]
__Fixes and Improvements__
* Add coarse grained lock around BSP request to avoid deadlocks {link-pr}/3243[#3243]
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-11-8]
=== 0.11.8 - 2024-06-21
:version: 0.11.8
:milestone-name: 0.11.8
:milestone: 93
:prev-version: 0.11.7
_Changes since {prev-version}:_
__New features__
* Support Scala Native 0.5.0 {link-pr}/3054[#3054] {link-pr}/3107[#3107] {link-pr}/3120[#3120]
* Add `jvmOptions` to docker contrib configuration {link-pr}/3079[#3079]
* Pass auxiliary class files to zinc, so they are deleted together {link-pr}/3072[#3072]
* BSP: Handle new `JvmCompileClasspath` request {link-pr}/3086[#3086]
* Add support for Cobertura XML report task to help integration {link-pr}/3093[#3093]
* Support Scala.js minify via `scalaJSMinify: T[String]` {link-pr}/3094[#3094]
* Restructure `TestModule`, add `RunModule` {link-pr}/3064[#3064]
* Move `run`-targets into `RunModule` {link-pr}/3090[#3090]
* `TestModule`: Support generation of JUnit-compatible xml report {link-pr}/3099[#3099] {link-pr}/3172[#3172] {link-pr}/3135[#3135] {link-pr}/3184[#3184]
* Use docker image hash to determine if build should rerun {link-pr}/3124[#3124]
* Add multi platform support to contrib.docker through docker buildx {link-pr}/3143[#3143]
* Add ability to re-write ESModule imports at link time {link-pr}/3109[#3109]
* Adding sonatype central support {link-pr}/3130[#3130] {link-pr}/3187[#3187]
* Add `TestModule.discoveredTestClasses` target to ease test inspection {link-pr}/3191[#3191]
* Support "pom" packaging type in `PublishModule` {link-pr}/3222[#3222]
__Fixes and Improvements__
* Restructure `VersionFinder`, increase speed, added ticker messages {link-pr}/3014[#3014]
* Fix bsp compile classpath inconsistencies {link-pr}/3017[#3017]
* Bring more bsp-specific targets in line with their non-bsp versions {link-pr}/3018[#3018]
* Make BSP task processing more resilient {link-pr}/3022[#3022]
* Update example `build.sc` with current library versions {link-pr}/3055[#3055]
* Scoverage: Do not include the scalac plugin in the reporting classpath {link-pr}/3060[#3060]
* Add Scala 2.13.13 and 2.12.19 to supported bridges list {link-pr}/3066[#3066]
* Fix BuildInfo static Java file generator {link-pr}/3074[#3074]
* Scoverage inner module defaults to `skipIdea = outer.skipIdea` {link-pr}/3098[#3098]
* Deduplicate input tasks in `inspect` command {link-pr}/3102[#3102]
* CI: add scalafix-check to precondition to publish {link-pr}/3095[#3095]
* Docs for Continuous cache invalidation {link-pr}/3096[#3096]
* Isolate scoverage modules from their parent modules {link-pr}/3118[#3118]
* Scoverage improve classpath override to the minimal {link-pr}/3122[#3122]
* Improve internal BSP API and docs, fix a match error condition {link-pr}/3111[#3111]
* Retry example integration tests that didn't finish after 5 minutes {link-pr}/3125[#3125]
* Fix mill script for parameter starting with -i {link-pr}/3127[#3127]
* Fixed semanticdb file copying issue, added more tests {link-pr}/3080[#3080]
* Detect assemblies with too many entries to fail shell script prepending {link-pr}/3140[#3140]
* Exclude mill provided dependencies in meta builds {link-pr}/3189[#3189] {link-pr}/3221[#3221]
* Fix Scala.js toolchain logs in server-client mode {link-pr}/3196[#3196]
* Fix compiler bridge build setup and build essential versions in CI {link-pr}/3179[#3179]
* Add Scala 2.13.14 to bridgeScalaVersions {link-pr}/3166[#3166]
* GenIdea improvements {link-pr}/3153[#3153]
* GenIdea: Use synthetic scala-SDK entry for compiler setup {link-pr}/3154[#3154]
* Fix classpath regression in Bloop export #1918 {link-pr}/3211[#3211]
* Support `build.sc` in Bloop {link-pr}/3208[#3208]
* Fail if `testOnly` does not match any test case {link-pr}/3224[#3224]
__Updates and internal changes__
* Code cleanups
* Documentation updates and fixes
* Test and CI improvements
* Updates: acyclic 0.3.12, Ammonite 3.0.0-M2-11-713b6963, asm 9.7,
commons-compress 1.26.2, commons-io 2.16.1, coursier 2.1.10,
fastparse 3.1.0, fansi 0.5.0,
guava 33.2.1,
jarjar-abrams-core 1.14.0, jline 3.26.2, junixsocket 2.9.1,
log4j-core 2.23.1,
mainargs 0.7.0 mill-mima 0.1.1, mill-scalafix 0.4.0,
os-lib 0.10.2,
Play 2.8.22 / 2.9.4 / 3.0.4, pprint 0.9.0, protobuf-java 3.25.3,
Scala 2.12.19 / 2.13.14,
Scala Native 0.4.17 / 0.5.3,
scala-xml 2.3.0,
scalacheck 1.18.0, scalatest 3.2.18, scoverage 2.1.1,
semanticdb-java 0.9.10, semanticdb-scalac 4.9.7
requests 0.8.3,
upickle 3.3.1, utest 0.8.3,
zinc 1.10.0
_For details refer to
{link-milestone}/{milestone}?closed=1[milestone {milestone-name}]
and the {link-compare}/{prev-version}\...{version}[list of commits]._
[#0-11-7]
=== 0.11.7 - 2024-02-05
:version: 0.11.7
:milestone-name: 0.11.7
:milestone: 91
:prev-version: 0.11.6
_Changes since {prev-version}:_
__New features__
* Support type selectors as path selection syntax in resolve {link-pr}/2997[#2997], {link-pr}/2998[#2998]
* Read coursier default config files to set up repositories and support mirror configuration {link-pr}/2886[#2886], {link-pr}/2917[#2917]
* Added support for `type` attribute when parsing dependencies {link-pr}/2994[#2994]
* Add new `ScalaModule.scalacHelp` command {link-pr}/2921[#2921]
* Add a `ScalaModule.consoleScalacOptions` target {link-pr}/2948[#2948]
* Enable colored output for Scala 2 compiler output {link-pr}/2950[#2950]
* Add `publishLocalCached` and `publishM2LocalCached` targets to `PublishModule` {link-pr}/2976[#2976]
* Support Scala Native build target. This allows to build static and dynamic libraries other than binaries {link-pr}/2898[#2898]
* Prepare the Scala.js integration for SIP-51 {link-pr}/2988[#2988]
__Fixes and Improvements__
* Better detect Windows Subsystem for Linux environments {link-pr}/2901[#2901]
* Avoid evaluating `Task.Input`s twice {link-pr}/2952[#2952]
* Deduplicate (anonymous) tasks in results {link-pr}/2959[#2959]
* Synchronize `evaluateGroupCached` to avoid concurrent access to cache {link-pr}/2980[#2980]
* Properly sanitize Windows reserved names and symbols in evaluator paths {link-pr}/2964[#2964], {link-pr}/2965[#2965]
* Detect colliding cross module values {link-pr}/2984[#2984]
* Mask forward slashes in cross values to fix their cache locations {link-pr}/2986[#2986]
* Re-enable test result summary (print `done` message from test framework to stdout) {link-pr}/2993[#2993]
* Fix overeager caching of `cliImports` value in `generatedScriptSources` {link-pr}/2977[#2977]
* Allow resolving moduleDeps with older Scala 3 versions {link-pr}/2877[#2877]
* GenIdea: Put module dependencies after library dependencies {link-pr}/2925[#2925]
* BSP: do not filter clean-requests for meta-builds {link-pr}/2931[#2931]
* BSP: Add `JavaModule.bspBuildTargetData` to make `JavaModule` reports workable `BuildTarget` {link-pr}/2930[#2930]
* BSP: Send `logMessage` instead of diagnostics when `textDocument` is unknown {link-pr}/2979[#2979]
* Scoverage inner module defaults new to `skipIdea = true` {link-pr}/2989[#2989]