Alexander Udalov
9df02b2366
Preface: for Groovy traits with fields, the Groovy compiler generates
synthetic "$Trait$FieldHelper" classes which posed several problems to
our class file reader, caused by the fact that the contents of the
InnerClasses attribute broke some assumptions about how names on the JVM
are formed and used.
For a trait named `A`, the Groovy compiler will additionally generate a
synthetic class file `A$Trait$FieldHelper` with the following in the
InnerClasses attribute:
InnerClasses:
public static #15= #2 of #14; //FieldHelper=class A$Trait$FieldHelper of class A
i.e. the simple name of the class is `FieldHelper`, the name of its
outer class is `A`, but the full internal name is `A$Trait$FieldHelper`,
which is surprising considering that the names are usually obtained by
separating the outer and inner names via the dollar sign.
Another detail is that in some usages of this synthetic class, the
InnerClasses attribute was missing at all. For example, if an empty
class `B` extends `A`, then there's no InnerClasses attribute in `B`'s
class file, which is surprising because we might decode the same name
differently depending on the class file we encounter it in.
In this change, we attempt to treat these synthetic classes as top-level
by refusing to read "invalid" InnerClasses attribute values (they are
not technically invalid because they still conform to JVMS), fixing the
problem of "unresolved supertypes" error which occurred when these
classes were used as supertypes in a class file in a dependency.
1) In ClassifierResolutionContext.mapInternalNameToClassId, do not use
the ad-hoc logic (copy-pasted from intellij-core) to determine class
id heuristically from the internal name. For $Trait$FieldHelper
classes this logic attempted to replace all dollar signs with dots,
which was semantically incorrect: dollars there were used as
synthetic characters, not as a separator between outer and inner
classes.
2) In isNotTopLevelClass (Other.kt), only consider "valid" InnerClasses
attribute values, where the full name of the class is obtained by
separating the outer name and the inner name with a dollar character.
This way, we'll be able to treat class files with invalid attribute
values as top-level and avoid breaking any other assumptions in the
class file loader.
3) In BinaryJavaClass.visitInnerClass, record all valid InnerClasses
attribute values present in the class file, not just those related to
the class in question itself. This is needed now because previously,
the removed heuristics (see p.1) transformed mentioned inner class
names to class ids correctly >99% of the time. Now that the
heuristics are gone, we'll use the information present in the class
file to map names correctly and predictably. According to JVMS, this
attribute should contain information about all inner classes
mentioned in the class file, and this is true at least for class
files produced by javac.
#KT-18592 Fixed
93 lines
7.7 KiB
Plaintext
Vendored
93 lines
7.7 KiB
Plaintext
Vendored
Usage: kotlinc-jvm <options> <source files>
|
|
where advanced options include:
|
|
-Xadd-compiler-builtins Add definitions of built-in declarations to the compilation classpath (useful with -no-stdlib)
|
|
-Xadd-modules=<module[,]> Root modules to resolve in addition to the initial modules,
|
|
or all modules on the module path if <module> is ALL-MODULE-PATH
|
|
-Xassertions={always-enable|always-disable|jvm|legacy}
|
|
Assert calls behaviour
|
|
-Xassertions=always-enable: enable, ignore jvm assertion settings;
|
|
-Xassertions=always-disable: disable, ignore jvm assertion settings;
|
|
-Xassertions=jvm: enable, depend on jvm assertion settings;
|
|
-Xassertions=legacy: calculate condition on each call, check depends on jvm assertion settings in the kotlin package;
|
|
default: legacy
|
|
-Xbuild-file=<path> Path to the .xml build file to compile
|
|
-Xcompile-java Reuse javac analysis and compile Java source files
|
|
-Xnormalize-constructor-calls={disable|enable}
|
|
Normalize constructor calls (disable: don't normalize; enable: normalize),
|
|
default is 'disable' in language version 1.2 and below,
|
|
'enable' since language version 1.3
|
|
-Xdump-declarations-to=<path> Path to JSON file to dump Java to Kotlin declaration mappings
|
|
-Xdisable-default-scripting-plugin
|
|
Do not enable scripting plugin by default
|
|
-Xdisable-standard-script Disable standard kotlin script support
|
|
-Xfriend-paths=<path> Paths to output directories for friend modules (whose internals should be visible)
|
|
-Xmultifile-parts-inherit Compile multifile classes as a hierarchy of parts and facade
|
|
-Xmodule-path=<path> Paths where to find Java 9+ modules
|
|
-Xjavac-arguments=<option[,]> Java compiler arguments
|
|
-Xjsr305={ignore/strict/warn}|under-migration:{ignore/strict/warn}|@<fq.name>:{ignore/strict/warn}
|
|
Specify behavior for JSR-305 nullability annotations:
|
|
-Xjsr305={ignore/strict/warn} globally (all non-@UnderMigration annotations)
|
|
-Xjsr305=under-migration:{ignore/strict/warn} all @UnderMigration annotations
|
|
-Xjsr305=@<fq.name>:{ignore/strict/warn} annotation with the given fully qualified class name
|
|
Modes:
|
|
* ignore
|
|
* strict (experimental; treat as other supported nullability annotations)
|
|
* warn (report a warning)
|
|
-Xjvm-default={disable|enable|compatibility}
|
|
Allow to use '@JvmDefault' annotation for JVM default method support.
|
|
-Xjvm-default=disable Prohibit usages of @JvmDefault
|
|
-Xjvm-default=enable Allow usages of @JvmDefault; only generate the default method
|
|
in the interface (annotating an existing method can break binary compatibility)
|
|
-Xjvm-default=compatibility Allow usages of @JvmDefault; generate a compatibility accessor
|
|
in the 'DefaultImpls' class in addition to the interface method
|
|
-Xload-builtins-from-dependencies
|
|
Load definitions of built-in declarations from module dependencies, instead of from the compiler
|
|
-Xno-call-assertions Don't generate not-null assertions for arguments of platform types
|
|
-Xno-exception-on-explicit-equals-for-boxed-null
|
|
Do not throw NPE on explicit 'equals' call for null receiver of platform boxed primitive type
|
|
-Xno-optimize Disable optimizations
|
|
-Xno-param-assertions Don't generate not-null assertions on parameters of methods accessible from Java
|
|
-Xno-receiver-assertions Don't generate not-null assertion for extension receiver arguments of platform types
|
|
-Xscript-resolver-environment=<key=value[,]>
|
|
Script resolver environment in key-value pairs (the value could be quoted and escaped)
|
|
-Xsingle-module Combine modules for source files and binary dependencies into a single module
|
|
-Xskip-runtime-version-check Allow Kotlin runtime libraries of incompatible versions in the classpath
|
|
-Xstrict-java-nullability-assertions
|
|
Generate nullability assertions for non-null Java expressions
|
|
-Xgenerate-strict-metadata-version
|
|
Generate metadata with strict version semantics (see kdoc on Metadata.extraInt)
|
|
-Xsupport-compatqual-checker-framework-annotations=enable|disable
|
|
Specify behavior for Checker Framework compatqual annotations (NullableDecl/NonNullDecl).
|
|
Default value is 'enable'
|
|
-Xuse-ir Use the IR backend
|
|
-Xuse-javac Use javac for Java source and class files analysis
|
|
-Xuse-old-class-files-reading Use old class files reading implementation. This may slow down the build and cause problems with Groovy interop.
|
|
Should be used in case of problems with the new implementation
|
|
-Xuse-type-table Use type table in metadata serialization
|
|
-Xallow-kotlin-package Allow compiling code in package 'kotlin' and allow not requiring kotlin.stdlib in module-info
|
|
-Xallow-result-return-type Allow compiling code when `kotlin.Result` is used as a return type
|
|
-Xcommon-sources=<path> Sources of the common module that need to be compiled together with this module in the multi-platform mode.
|
|
Should be a subset of sources passed as free arguments
|
|
-Xcoroutines={enable|warn|error}
|
|
Enable coroutines or report warnings or errors on declarations and use sites of 'suspend' modifier
|
|
-Xdump-perf=<path> Dump detailed performance statistics to the specified file
|
|
-Xeffect-system Enable experimental language feature: effect system
|
|
-Xexperimental=<fq.name> Enable and propagate usages of experimental API for marker annotation with the given fully qualified name
|
|
-Xintellij-plugin-root=<path> Path to the kotlin-compiler.jar or directory where IntelliJ configuration files can be found
|
|
-Xlegacy-smart-cast-after-try Allow var smart casts despite assignment in try block
|
|
-Xmetadata-version Change metadata version of the generated binary files
|
|
-Xmulti-platform Enable experimental language support for multi-platform projects
|
|
-Xnew-inference Enable new experimental generic type inference algorithm
|
|
-Xno-check-actual Do not check presence of 'actual' modifier in multi-platform projects
|
|
-Xno-inline Disable method inlining
|
|
-Xplugin=<path> Load plugins from the given classpath
|
|
-Xproper-ieee754-comparisons Generate proper IEEE 754 comparisons in all cases if values are statically known to be of primitive numeric types
|
|
-Xread-deserialized-contracts Enable reading of contracts from metadata
|
|
-Xreport-output-files Report source to output files mapping
|
|
-Xreport-perf Report detailed performance statistics
|
|
-Xskip-metadata-version-check Load classes with bad metadata version anyway (incl. pre-release classes)
|
|
-Xuse-experimental=<fq.name> Enable, but don't propagate usages of experimental API for marker annotation with the given fully qualified name
|
|
|
|
Advanced options are non-standard and may be changed or removed without any notice.
|
|
OK
|