Fix some of the usages of KotlinSyntheticClass header where really package
parts were meant (they were committed by mistake).
DescriptorResolverUtils.isCompiledKotlinPackageClass no longer checks for class
being a compiled package part, because PSI classes are not built for package
parts (according to EmptyPackageFragmentClsStubBuilderFactory)
Will be used instead of KotlinPackagePart, KotlinTraitImpl and other
hypothetical annotations we were planning to write on our synthesized classes
(lambdas, local functions, etc.)
Delete reflected usages of annotation classes (JetValueParameter.class,
KotlinSignature.class, etc.). It's wrong: this is a dependency on the old
runtime, whereas the compiler should work with the new one
To differentiate between "String?.plus" extension in builtins and
"Iterable<*>.plus" extension in stdlib (they have the same owner, name and
value parameter count)
Use reflection in ProgressionUtilTest instead of calling methods on the class
from the class path, because in the latter case we were just testing
ProgressionUtil from bootstrap runtime (which, presumably, always works
correctly since it's a bootstrap distribution)
With this change, compilable built-ins (under core/builtins/src) are fully
written in Kotlin
Otherwise generic signature wasn't correctly written to accessors, resulting in
classfiles not being valid and javac failing to compile Java sources against
them
Code containing breaks or continues that attempt to jump across a
function boundary weren't detected during analysis but would crash
the compiler during code generation. Add diagnostics for these kinds
of errors.
Example:
fun f() {
while (true) {
fun inner() {
continue
}
}
}
#KT-4334 Fixed
The basic principle behind this change is that no context object should store components.
Components should be injected instead, and contexts only carry parameters around.
Particular changes:
- resolveCallWithGivenName() and resolveBinaryCall() moved to CallResolver
- ForLoopConventionsChecker introduced to confine checking conventions for Iterator and Iterable
- ExpressionTypingComponents introduced to deliver necessary components to ExpressionTypingVisitor's
- Some static methods became non-static to get access to injected components
- ExpressionTypingUtils and ControlStructureTypingUtils became components (got state injected) to avoid passing parameters around
Minimize usages of jet.* in Java code: this will help in migration of jet.* to
package kotlin. Since tests will work with fq names instead of Class<?>
instances from now on, ClassLoaderIsolationUtil is useless now (except for one
unrelated method, which was moved to CodegenTestUtil)
This is needed because our built-ins can be loaded with two different
mechanisms (deserialization and lazy resolve) and, when that happens,
corresponding descriptors aren't equal to each other, so one of two resolved
descriptors for Any (or the same with Nothing) was never considered to be a
"special class" with no supertypes
Natalia Ukhorskaya