But not substitution overrides! This is important if the method called
is an intersection override where one of the intersected types is a
subtype of a generic type.
This is because it is only needed for the declaration itself, not for
the containing class. Currently there is no difference because
`containingNonLocalClass` will look at the dispatch receiver argument if
one exists anyway, and for substitution/intersection overrides one must
exist.
'originalForSubstitutionOverrideAttr' is supposed to be on all
'SubstitutionOverride' declarations, and certain functionality, such as
'KtFirOverrideInfoProvider#getOriginalOverriddenSymbol()' depends on it.
Absence of the attribute might trigger infinite loop/recursion in
substitution unwrapping.
A non-trivial intersection override should be created if:
1. the base methods are from different classes (for proper reporting of
diagnostics if an override is necessary);
2. OR the return type might need to be intersected (which currently
happens for non-subtyping scopes if there is no single maximally
specific declaration)
When suspend function type is serialized, there is special logic that
adds Continuation parameter, before doing so, type-aliases has to be
expanded, attributes for resulting type should also derive from
expanded type
KT-53193, KT-54062
The previous attempt stopped this code from throwing an exception during
serialization, but the arity is still wrong so an exception is now throw
when reading the serialized type.
^KT-50997 Fixed
Right now it is the easiest way to ensure that all the parameters are
resolved. After KT-53573 is fixed, we might use `resolvedReturnTypeRef`
on each parameter individually instead
Also, add `toString` implementation to `ValueClassRepresentation`
classes, so they are properly rendered in testdata
^KTIJ-22630 Fixed
Review: https://jetbrains.team/p/kt/reviews/6753
All redundant I managed to find, of course.
Why: I'm going to process all reflect dependencies in the next commits.
Cleanup reflect dependency before processing.
They are redundant because:
1. if `compileOnly` then compilation didn't break after dropping the
dependency
2. if `test*` then tests didn't break after dropping the dependency.
3. `analysis/analysis-api-fir/analysis-api-fir-generator/build.gradle.kts`
`compiler/fir/checkers/checkers-component-generator/build.gradle.kts`
Drop `implementation(project(":kotlin-reflect-api"))` because the
module already depends on
`implementation(project(":kotlin-reflect"))`
4. `compiler/daemon/daemon-client/build.gradle.kts`. Drop `runtimeOnly`
because after dropping `compileOnly` compilation didn't break (so
`runtimeOnly` looks suspicious). Less safe than 1-3
Mikhail Glukhikh