We are planning to improve incremental Kotlin compile with a new
approach using classpath snapshot (see
https://youtrack.jetbrains.com/issue/KT-45777 for more details).
The estimated steps will be as follows:
[x] Add a flag for the new approach, disabled by default
[ ] Add tests for the new approach, and update them as we go
[ ] Add computation of classpath snapshot using artifact transforms
[ ] Add computation of classpath snapshot changes
[ ] Ensure incremental compile is fully functional with the new approach
[ ] Measure performance + optimize: Repeat until we see evidence that
the new approach is clearly better than the current approach
[ ] Advertise the flag, and later on enable it by default
This commit is the first step. Although it's simple, it allows further
changes to be made safely without impacting the current approach.
Bug: KT-45777
Test: N/A (will be added in a subsequent change)
1. if an argument of a `pop` cannot be removed, then all other potential
arguments of that `pop` can't be removed either, and the same applies
to other `pop`s that touch them;
2. the same is true for primitive conversions, but this is even trickier
to implement correctly, so I simply did the same thing as with
boxing operators: replace the conversion itself with a `pop` and keep
the argument as-is.
Somehow this actually removes *more* redundant primitive type conversions
than the old code in a couple bytecode text tests, so I've patched them
to kind of use the value, forcing the instructions to stay.
#KT-46921 Fixed
Disable Idea JPS build mechanism for marking all sources of common output if one of them is dirty
Add source-to-outputs map for correctly removing Kotlin/JS outputs
#KT-45763 Fixed
#KT-44351 Fixed
CoroutineTransformermethodVisitor attempts to extend the ranges
of local variables in various situations. Probably in an attempt
to give a better debugging experience. However, all of these
range extensions lead to invalid local variable tables where
something is in the local variable table where nothing is in the
corresponding slot.
The code that extends variables to the next suspension point
instead of ending them when they are no longer live has issues
with loops. When resuming and reentering the loop, the locals
table will mention a local that we did not spill and which
is therefore not restored when resuming.
The code that extends local variable table entries if there
are no suspension points between two entries doesn't work
for code such as:
```
var s: String
if (suspendHere() == "OK") {
s = "OK"
} else {
s = "FAIL"
}
```
If the local variable ranges are collapsed into one, one of
the branches will have the local defined in the local variable
table before the slot is initialized.
Gradle's detached configurations doesn't respect extends from relation
to other configurations due to gradle bug.
In fact extendsFrom isn't required for resolvableMetadataConfiguration
business logic. It is enough to include all originalDependencies to
freshly created detached configuration.
^KT-46417 Fixed
Nikolay Krasko