It was error-prone, not very useful (only a couple seconds saved on a 3min
build), and in fact did not work since 5194310d, because <skip> element was
failing inside the default javac
It's necessary to use bootstrap-compiler and runtime but new compiler in classpath when increasing ABI.
For example ABI was X, then we increase it to X':
- It compiles in Bootstrap (B) build with compiler that knows
old ABI version, so compiled compiler (C1) will still have version X, but new
runtime's version is X' (R1).
So when we compile android-compiler-plugin each part has version X.
- Then project compiles by new compiler (C1)
(that class-files have ABI version X, but it knows about X') in main build.
Here compiled compiler (C2) will have X' version of class-files,
either has runtime (R1) compiled on previous stage.
On this step android-compiler-plugin will be compiled fine by C1 and with C2, R1.
Reflection will be distributed in a separate jar and not in kotlin-runtime.jar
for two primary reasons:
- Reflection implementation at the moment takes almost 2Mb
- Separate libraries for separate features is a technique encouraged by Maven,
and it's inconvenient to make it different in the compiler distribution
Generate K*Function as a supertype for a function reference instead of
K*FunctionImpl; this will allow one binary library to be used with or without
reflection
- passing sources to "-classpath" is no longer needed because the logic was
implemented in K2JVMCompiler
- skipping javac2 for stdlib is no longer needed because the corresponding
error is no longer reproducible since "skip" was added to javac2
- get rid of unneeded properties in favor of Ant's toString feature
We skip all classes annotated with kotlin/jvm/internal/<anything> (currently
KotlinClass, KotlinPackage and KotlinSyntheticClass) because Kotlin compiler
emits its own nullability assertions
Do not pack the runtime into the compiler on the first step of bootstrap, but
rather leave it as a separate file named kotlin-runtime-internal-bootstrap.jar.
This new solution will allow compiler to use its own classes from "core", not
the ones used by the runtime it depends on
Alexander Udalov