Before this change, it could happen that `when` of type Unit has a
branch whose type is not Unit. This can lead to problems in IR
lowerings, for example PolymorphicSignatureLowering which is very
reliant on the correct types of expressions and placement of coercions
to Unit (KT-59218).
Otherwise, according to the spec, a type will be treated as a final,
which is not correct in many cases.
Later, we can generate final struct types when it's applicable.
#KT-60200 Fixed
In REPL it's possible that builtins will be created several times with
the same symbol table. And since IrBuiltinsPackageFragmentDescriptorImpl
has overridden equals, symbol for external package will be the same for
different descriptors (with same FQN). So we should create IrExternalPackageFragment
here only if it was not created before, on previous compilation
After this change SymbolTable (and ReferenceSymbolTable) contains only
methods with IdSignatures. All descriptors-related methods are moved
into DescriptorSymbolTableExtension, which automatically delegates to
the SymbolTable if needed
At this moment there are cross-references between SymbolTable, because
descriptor API is still actively used across backends. So SymbolTable
is accessible in some place then descriptor extension will be accessible
too
DescriptorSymbolTableExtension is an implementation of abstract SymbolTableExtension
which allows to implement different kinds of storages, e.g. FIR based
(it probably will be needed for FIR2IR)
For interfaces with custom serializer (@Serializer(`SerializerType::class)`) now the `serializer()` function is generated in the companion so that user can get a serializer by type
Merge-request: KT-MR-11040
Merged-by: Sergey Shanshin <Sergey.Shanshin@jetbrains.com>
Use it in diagnostic tests with JVM backend instead of the
RENDER_DIAGNOSTICS_FULL_TEXT directive.
This is needed because otherwise in
AbstractDiagnosticsTestWithJvmBackend there are two handlers trying to
dump full diagnostic texts: JvmBackendDiagnosticsHandler and
FirDiagnosticsHandler, which dump different diagnostics (reported by
backend vs frontend) and in slightly different formats.
In fact, this is why exceptionFromInterpreter.fir.diag.txt was added in
48484368c7: the existing .diag.txt was detected as incorrect by
FirDiagnosticsHandler (even though the diagnostics are the same, just
printed in a different way), which led to the creation of .fir.diag.txt.
For these tests, the behavior about checking diagnostic text in
FirDiagnosticsHandler is useless because it doesn't include backend
diagnostics. So we disable it by using another directive.
Remove the "_ir" suffix. It was originally used to distinguish tests on
the JVM IR backend from the old JVM backend ("_old"), but the latter are
removed now.
Also take into account diagnostics reported via
GenerationState.collectedExtraJvmDiagnostics, and render them in the
similar format to KtDiagnostic.
Don't make the test pass if the reported list of diagnostics is empty,
because that defeats the purpose of the test.
`FragmentLocalFunctionPatchLowering.visitSimpleFunction`
uses a transformer with an overridden `visitCall`.
Inside it visits every nested call recursively in two places:
in the beginning (1, line 59), and via super method
if the current call doesn't refer to a local function (2, line 64).
It leads to a combinatorial explosion: if there are N nested calls
in one expression, then the number of `visitCall` invocations
will be `pow(2, N)`.
Thus, it will take forever to compile certain expressions. A perfect
example of a long nested call is string interpolation: string templates
are being compiled to a chain of `StringBuilder::append` calls. Here's
why IDEA-325225 happens -- the code in the issue has large string
templates, and the resulting `StringBuilder::append` chains may contain
up to 30 links, making for around 1 billion `visitCall` invocations.
However, the visiting (2) is obsolete. First, the visiting (1) will
process all the children of an expression, replacing them with the
right local function calls, if necessary, recursively, up the stack.
Second, the expression itself will be transformed, if necessary, in
that same method, after all its children are processed. That means we
can get rid of one visiting and avoid the combinatorial explosion, yet
all the local function calls will still be correctly processed.
Fixes IDEA-325225, contributes to IDEA-325146
Merge-request: KT-MR-11104
Merged-by: Alexander Kuznetsov <Aleksander.Kuznetsov@jetbrains.com>
Alexander Udalov