Artifact transform used to analyze classpath was not closing files, which
caused java.nio.file.FileSystemException. This commit fixes that, and all
input streams are closed after use.
Fixes: KT-31714
This commit changes how generated sources are added to the Gradle JavaCompile
task. Previously, directory was added to sources which caused issues with
annotation processors that only generate Kotlin sources. I.e. JavaCompile task
was executed but no java sources existed.
Now, only generated Java sources are added to the JavaCompile task. This
means that if only Kotlin sources are generated JavaCompile task will be
skipped.
Fixes: KT-31127
Test: Kapt3IT.testKotlinProcessorUsingFiler
KaptFlag.INCREMENTAL_APT is used to indicate that KAPT run
should try to be incremental because changes to input files and
classpath have been detected. However, first run of the Gradle
task will set this flag to false, which means that all APs will be
detected as non-incremental in the first run. Further on, this means
that the dependency caches will be invalid, and all subsequent runs
will be non-incremental as well.
This commit uses existence of dependency cache to determine if incremental
APs should be discovered. The regression was introduced in
72fdc648ff.
Test: ./gradlew :kotlin-gradle-plugin-integration-tests:testAdvanceGradleVersion --tests *KaptIncrementalWith*\
&& ./gradlew :kotlin-gradle-plugin-integration-tests:test --tests *KaptIncrementalWith*
It is possible for isolating annotation processor to report two or more
originating elements from the same source file when generating
sources/classes/resources. This commit makes sure the source file are
de-duped, so assertion that there is a single source file does not fail.
Test: IsolatingIncrementalProcessorsTest.testIsolatingWithMultipleOriginatingElements
This is improvement to https://youtrack.jetbrains.com/issue/KT-23880
When analyzing source files in KAPT for incremental annotation processing,
avoid creating TreePath instances for initializers that are literals. E.g.
if it is just a boolean/int literal, we do not need to visit the tree nor
create expensive TreePath instance.
For classes that contain only constants (such as R.java for Android projects)
this is a significant improvement. Class that contains 16000 constants took
more than 10 seconds to analyze, now it is 70ms.
Ideally, the type of `IrWhen` should be provided by type inference for
a consistent behavior. `USED_AS_EXPRESSION` from CFG isn't always
consistent with type inference, unfortunately.
The behavior is now aligned with `if`. The type of `when` is kept when
it *can* be an expression, instead of whether it is used or not.
- already visited transitive npm dependencies should be stored in parent dependencies
- child NpmDependency should search resolved project data in parent NpmDependencies
Plus, additionally fix evaluation of generic local functions everywhere
The problem was that in new-inference we create more substituted
descriptors while old inference tries to preserve original ones.
Later, backend fails to retrieve those descriptors as it uses originals.
But, again, this worked only for simple functions, for generic functions
debugger with new and old inference worked incorrectly
#KT-31785 Fixed
- Root buildscript classpath no more depends on buildSrc.jar from kotlin-ultimate. This allows to have stable joint builds - w/o occasional "Unresolved reference" errors in buildscripts.
- kotlin-ultimate modules are now included into Kotlin project when two conditions are met: 1) Gradle parameter 'cidrPluginsEnabled' is turned on; 2) kotlin-ultimate Git repo is checked out right to the Kotlin project root (assuming there is 'kotlin-ultimate' directory inside the project root).
Alexander Udalov