azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate diagnostic names for header/impl

Browse Source
This commit is contained in:
Stanislav Erokhin
2017-09-14 23:51:51 +03:00
committed by Mikhail Glukhikh
parent d20ba5d082
commit 2b186909d4
32 changed files with 115 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+17 -16
View File
@@ -554,30 +554,31 @@ public interface Errors {
// Multi-platform projects
DiagnosticFactory0<KtDeclaration> HEADER_DECLARATION_WITH_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtParameter> HEADER_DECLARATION_WITH_DEFAULT_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtConstructorDelegationCall> HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtParameter> HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtConstructor<?>> HEADER_ENUM_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtEnumEntry> HEADER_ENUM_ENTRY_WITH_BODY = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> HEADER_PROPERTY_INITIALIZER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtDeclaration> EXPECTED_DECLARATION_WITH_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtParameter> EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtConstructorDelegationCall> EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtParameter> EXPECTED_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtConstructor<?>> EXPECTED_ENUM_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtEnumEntry> EXPECTED_ENUM_ENTRY_WITH_BODY = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> EXPECTED_PROPERTY_INITIALIZER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_NOT_TO_CLASS = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> ACTUAL_TYPE_ALIAS_NOT_TO_CLASS = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias>
ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory3<KtDeclaration, MemberDescriptor, ModuleDescriptor,
Map<Incompatible, Collection<MemberDescriptor>>> HEADER_WITHOUT_IMPLEMENTATION =
Map<Incompatible, Collection<MemberDescriptor>>> NO_ACTUAL_FOR_EXPECT =
DiagnosticFactory3.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory2<KtDeclaration, MemberDescriptor,
Map<Incompatible, Collection<MemberDescriptor>>> IMPLEMENTATION_WITHOUT_HEADER =
Map<Incompatible, Collection<MemberDescriptor>>> ACTUAL_WITHOUT_EXPECT =
DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory2<KtDeclaration, ClassDescriptor,
List<Pair<MemberDescriptor, Map<Incompatible, Collection<MemberDescriptor>>>>> HEADER_CLASS_MEMBERS_ARE_NOT_IMPLEMENTED =
List<Pair<MemberDescriptor, Map<Incompatible, Collection<MemberDescriptor>>>>> NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS =
DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtDeclaration> IMPL_MISSING = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtDeclaration> ACTUAL_MISSING = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -603,7 +604,7 @@ public interface Errors {
enum BadNamedArgumentsTarget {
NON_KOTLIN_FUNCTION,
INVOKE_ON_FUNCTION_TYPE,
HEADER_CLASS_MEMBER,
EXPECTED_CLASS_MEMBER,
}
DiagnosticFactory0<KtExpression> VARARG_OUTSIDE_PARENTHESES = DiagnosticFactory0.create(ERROR);
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+16 -16
View File
@@ -194,7 +194,7 @@ public class DefaultErrorMessages {
return "non-Kotlin functions";
case INVOKE_ON_FUNCTION_TYPE:
return "function types";
case HEADER_CLASS_MEMBER:
case EXPECTED_CLASS_MEMBER:
return "members of header classes";
default:
throw new AssertionError(target);
@@ -262,27 +262,27 @@ public class DefaultErrorMessages {
MAP.put(MULTIPLE_VARARG_PARAMETERS, "Multiple vararg-parameters are prohibited");
MAP.put(FORBIDDEN_VARARG_PARAMETER_TYPE, "Forbidden vararg parameter type: {0}", RENDER_TYPE);
MAP.put(HEADER_DECLARATION_WITH_BODY, "Header declaration must not have a body");
MAP.put(HEADER_DECLARATION_WITH_DEFAULT_PARAMETER, "Header declaration cannot have parameters with default values");
MAP.put(HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL, "Explicit delegation call for constructor of a header class is not allowed");
MAP.put(HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER, "Header class constructor cannot have a property parameter");
MAP.put(HEADER_ENUM_CONSTRUCTOR, "Header enum class cannot have a constructor");
MAP.put(HEADER_ENUM_ENTRY_WITH_BODY, "Header enum entry cannot have a body");
MAP.put(HEADER_PROPERTY_INITIALIZER, "Header property cannot have an initializer");
MAP.put(EXPECTED_DECLARATION_WITH_BODY, "Header declaration must not have a body");
MAP.put(EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER, "Header declaration cannot have parameters with default values");
MAP.put(EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL, "Explicit delegation call for constructor of a header class is not allowed");
MAP.put(EXPECTED_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER, "Header class constructor cannot have a property parameter");
MAP.put(EXPECTED_ENUM_CONSTRUCTOR, "Header enum class cannot have a constructor");
MAP.put(EXPECTED_ENUM_ENTRY_WITH_BODY, "Header enum entry cannot have a body");
MAP.put(EXPECTED_PROPERTY_INITIALIZER, "Header property cannot have an initializer");
MAP.put(IMPL_TYPE_ALIAS_NOT_TO_CLASS, "Right-hand side of 'impl' type alias should be a class, not another type alias");
MAP.put(IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE, "Aliased class should not have type parameters with declaration-site variance");
MAP.put(IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE, "Right-hand side of 'impl' type alias cannot contain use-site variance or star projections");
MAP.put(IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION, "Type arguments in the right-hand side of 'impl' type alias should be its type parameters in the same order, e.g. 'impl typealias Foo<A, B> = Bar<A, B>'");
MAP.put(ACTUAL_TYPE_ALIAS_NOT_TO_CLASS, "Right-hand side of 'impl' type alias should be a class, not another type alias");
MAP.put(ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE, "Aliased class should not have type parameters with declaration-site variance");
MAP.put(ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE, "Right-hand side of 'impl' type alias cannot contain use-site variance or star projections");
MAP.put(ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION, "Type arguments in the right-hand side of 'impl' type alias should be its type parameters in the same order, e.g. 'impl typealias Foo<A, B> = Bar<A, B>'");
MAP.put(HEADER_WITHOUT_IMPLEMENTATION, "''header'' {0} has no implementation in module{1}{2}", DECLARATION_NAME_WITH_KIND,
MAP.put(NO_ACTUAL_FOR_EXPECT, "''header'' {0} has no implementation in module{1}{2}", DECLARATION_NAME_WITH_KIND,
PLATFORM, PlatformIncompatibilityDiagnosticRenderer.TEXT);
MAP.put(IMPLEMENTATION_WITHOUT_HEADER, "''impl'' {0} has no corresponding ''header'' declaration{1}", DECLARATION_NAME_WITH_KIND,
MAP.put(ACTUAL_WITHOUT_EXPECT, "''impl'' {0} has no corresponding ''header'' declaration{1}", DECLARATION_NAME_WITH_KIND,
PlatformIncompatibilityDiagnosticRenderer.TEXT);
MAP.put(HEADER_CLASS_MEMBERS_ARE_NOT_IMPLEMENTED, "''impl'' class ''{0}'' has no implementation of ''header'' class members:{1}",
MAP.put(NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS, "''impl'' class ''{0}'' has no implementation of ''header'' class members:{1}",
NAME, IncompatibleHeaderImplClassScopesRenderer.TEXT);
MAP.put(IMPL_MISSING, "Declaration should be marked with 'impl' (suppress with -Xno-check-impl)");
MAP.put(ACTUAL_MISSING, "Declaration should be marked with 'impl' (suppress with -Xno-check-impl)");
MAP.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, "Projections are not allowed on type arguments of functions and properties");
MAP.put(SUPERTYPE_NOT_INITIALIZED, "This type has a constructor, and thus must be initialized here");
compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+1 -1
View File
@@ -618,7 +618,7 @@ public class BodyResolver {
trace.report(ANONYMOUS_INITIALIZER_IN_INTERFACE.on(anonymousInitializer));
}
if (classDescriptor.isExpect()) {
trace.report(HEADER_DECLARATION_WITH_BODY.on(anonymousInitializer));
trace.report(EXPECTED_DECLARATION_WITH_BODY.on(anonymousInitializer));
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt
+13 -13
View File
@@ -175,23 +175,23 @@ class DeclarationsChecker(
val rhs = typeAliasDescriptor.underlyingType
val classDescriptor = rhs.constructor.declarationDescriptor
if (classDescriptor !is ClassDescriptor) {
trace.report(IMPL_TYPE_ALIAS_NOT_TO_CLASS.on(declaration))
trace.report(ACTUAL_TYPE_ALIAS_NOT_TO_CLASS.on(declaration))
return
}
if (classDescriptor.declaredTypeParameters.any { it.variance != Variance.INVARIANT }) {
trace.report(IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE.on(declaration))
trace.report(ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE.on(declaration))
return
}
if (rhs.arguments.any { it.projectionKind != Variance.INVARIANT || it.isStarProjection }) {
trace.report(IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE.on(declaration))
trace.report(ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE.on(declaration))
return
}
if (rhs.arguments.map { it.type.constructor.declarationDescriptor as? TypeParameterDescriptor } !=
typeAliasDescriptor.declaredTypeParameters) {
trace.report(IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION.on(declaration))
trace.report(ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION.on(declaration))
return
}
}
@@ -253,17 +253,17 @@ class DeclarationsChecker(
if (!constructorDescriptor.isExpect) return
if (declaration.hasBody()) {
trace.report(HEADER_DECLARATION_WITH_BODY.on(declaration))
trace.report(EXPECTED_DECLARATION_WITH_BODY.on(declaration))
}
if (constructorDescriptor.containingDeclaration.kind == ClassKind.ENUM_CLASS) {
trace.report(HEADER_ENUM_CONSTRUCTOR.on(declaration))
trace.report(EXPECTED_ENUM_CONSTRUCTOR.on(declaration))
}
if (declaration is KtPrimaryConstructor && !DescriptorUtils.isAnnotationClass(constructorDescriptor.constructedClass)) {
for (parameter in declaration.valueParameters) {
if (parameter.hasValOrVar()) {
trace.report(HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER.on(parameter))
trace.report(EXPECTED_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER.on(parameter))
}
}
}
@@ -271,7 +271,7 @@ class DeclarationsChecker(
if (declaration is KtSecondaryConstructor) {
val delegationCall = declaration.getDelegationCall()
if (!delegationCall.isImplicit) {
trace.report(HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL.on(delegationCall))
trace.report(EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL.on(delegationCall))
}
}
}
@@ -637,7 +637,7 @@ class DeclarationsChecker(
if (initializer != null) {
when {
inInterface -> trace.report(PROPERTY_INITIALIZER_IN_INTERFACE.on(initializer))
isExpect -> trace.report(HEADER_PROPERTY_INITIALIZER.on(initializer))
isExpect -> trace.report(EXPECTED_PROPERTY_INITIALIZER.on(initializer))
!backingFieldRequired -> trace.report(PROPERTY_INITIALIZER_NO_BACKING_FIELD.on(initializer))
property.receiverTypeReference != null -> trace.report(EXTENSION_PROPERTY_WITH_BACKING_FIELD.on(initializer))
}
@@ -731,12 +731,12 @@ class DeclarationsChecker(
private fun checkHeaderFunction(function: KtNamedFunction) {
if (function.hasBody()) {
trace.report(HEADER_DECLARATION_WITH_BODY.on(function))
trace.report(EXPECTED_DECLARATION_WITH_BODY.on(function))
}
for (parameter in function.valueParameters) {
if (parameter.hasDefaultValue()) {
trace.report(HEADER_DECLARATION_WITH_DEFAULT_PARAMETER.on(parameter))
trace.report(EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER.on(parameter))
}
}
}
@@ -790,7 +790,7 @@ class DeclarationsChecker(
) {
if (accessor == null || accessorDescriptor == null) return
if (propertyDescriptor.isExpect && accessor.hasBody()) {
trace.report(HEADER_DECLARATION_WITH_BODY.on(accessor))
trace.report(EXPECTED_DECLARATION_WITH_BODY.on(accessor))
}
val accessorModifierList = accessor.modifierList ?: return
@@ -831,7 +831,7 @@ class DeclarationsChecker(
if (DescriptorUtils.isEnumClass(enumClass)) {
if (enumClass.isExpect) {
if (enumEntry.getBody() != null) {
trace.report(HEADER_ENUM_ENTRY_WITH_BODY.on(enumEntry))
trace.report(EXPECTED_ENUM_ENTRY_WITH_BODY.on(enumEntry))
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
+1 -1
View File
@@ -187,7 +187,7 @@ public class ValueArgumentsToParametersMapper {
candidate.getContainingDeclaration() instanceof ClassDescriptor) {
// We do not allow named arguments for members of header classes until we're able to use both
// headers and platform definitions when compiling platform code
report(NAMED_ARGUMENTS_NOT_ALLOWED.on(nameReference, HEADER_CLASS_MEMBER));
report(NAMED_ARGUMENTS_NOT_ALLOWED.on(nameReference, EXPECTED_CLASS_MEMBER));
}
else if (!candidate.hasStableParameterNames()) {
report(NAMED_ARGUMENTS_NOT_ALLOWED.on(
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt
+4 -4
View File
@@ -92,7 +92,7 @@ object ExpectedActualDeclarationChecker : DeclarationChecker {
assert(compatibility.keys.all { it is Incompatible })
@Suppress("UNCHECKED_CAST")
val incompatibility = compatibility as Map<Incompatible, Collection<MemberDescriptor>>
diagnosticHolder.report(Errors.HEADER_WITHOUT_IMPLEMENTATION.on(reportOn, descriptor, platformModule, incompatibility))
diagnosticHolder.report(Errors.NO_ACTUAL_FOR_EXPECT.on(reportOn, descriptor, platformModule, incompatibility))
}
}
@@ -132,7 +132,7 @@ object ExpectedActualDeclarationChecker : DeclarationChecker {
if (Compatible !in compatibility) return
if (checkExpected) {
diagnosticHolder.report(Errors.IMPL_MISSING.on(reportOn))
diagnosticHolder.report(Errors.ACTUAL_MISSING.on(reportOn))
}
}
@@ -164,7 +164,7 @@ object ExpectedActualDeclarationChecker : DeclarationChecker {
val classDescriptor =
(descriptor as? TypeAliasDescriptor)?.expandedType?.constructor?.declarationDescriptor as? ClassDescriptor
?: (descriptor as ClassDescriptor)
diagnosticHolder.report(Errors.HEADER_CLASS_MEMBERS_ARE_NOT_IMPLEMENTED.on(
diagnosticHolder.report(Errors.NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS.on(
reportOn, classDescriptor, nonTrivialUnimplemented
))
}
@@ -173,7 +173,7 @@ object ExpectedActualDeclarationChecker : DeclarationChecker {
assert(compatibility.keys.all { it is Incompatible })
@Suppress("UNCHECKED_CAST")
val incompatibility = compatibility as Map<Incompatible, Collection<MemberDescriptor>>
diagnosticHolder.report(Errors.IMPLEMENTATION_WITHOUT_HEADER.on(reportOn, descriptor, incompatibility))
diagnosticHolder.report(Errors.ACTUAL_WITHOUT_EXPECT.on(reportOn, descriptor, incompatibility))
}
}
compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt
Vendored
+2 -2
View File
@@ -2,12 +2,12 @@
// MODULE: m1-common
// FILE: common.kt
expect enum class En<!HEADER_ENUM_CONSTRUCTOR!>(x: Int)<!> {
expect enum class En<!EXPECTED_ENUM_CONSTRUCTOR!>(x: Int)<!> {
E1,
E2(42),
;
<!HEADER_ENUM_CONSTRUCTOR!>constructor(s: String)<!>
<!EXPECTED_ENUM_CONSTRUCTOR!>constructor(s: String)<!>
}
expect enum class En2 {
compiler/testData/diagnostics/tests/multiplatform/enum/enumEntryWithBody.kt
Vendored
+3 -3
View File
@@ -4,8 +4,8 @@
expect enum class En {
E1,
<!HEADER_ENUM_ENTRY_WITH_BODY!>E2 {
<!HEADER_DECLARATION_WITH_BODY!>fun foo()<!> = ""
<!EXPECTED_ENUM_ENTRY_WITH_BODY!>E2 {
<!EXPECTED_DECLARATION_WITH_BODY!>fun foo()<!> = ""
},<!>
<!HEADER_ENUM_ENTRY_WITH_BODY!>E3 { };<!>
<!EXPECTED_ENUM_ENTRY_WITH_BODY!>E3 { };<!>
}
compiler/testData/diagnostics/tests/multiplatform/headerClass/explicitConstructorDelegation.kt
Vendored
+2 -2
View File
@@ -4,11 +4,11 @@
expect open class A {
constructor(s: String)
constructor(n: Number) : <!HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("A")
constructor(n: Number) : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("A")
}
expect class B : A {
constructor(i: Int)
constructor() : <!HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL!>super<!>("B")
constructor() : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>super<!>("B")
}
compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.kt
Vendored
+8 -8
View File
@@ -1,4 +1,4 @@
// !DIAGNOSTICS: -IMPLEMENTATION_WITHOUT_HEADER
// !DIAGNOSTICS: -ACTUAL_WITHOUT_EXPECT
// !LANGUAGE: +MultiPlatformProjects
// MODULE: m1-common
// FILE: common.kt
@@ -18,14 +18,14 @@ expect interface C10<L>
// FILE: jvm.kt
actual typealias C1 = String
<!IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE!>actual typealias C2<<!UNUSED_TYPEALIAS_PARAMETER!>A<!>> = List<String><!>
<!IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE!>actual typealias C3<B> = List<B><!>
<!ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE!>actual typealias C2<<!UNUSED_TYPEALIAS_PARAMETER!>A<!>> = List<String><!>
<!ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE!>actual typealias C3<B> = List<B><!>
actual typealias C4<D, E> = MutableMap<D, E>
<!IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C5<F, G> = MutableMap<G, F><!>
<!ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION!>actual typealias C5<F, G> = MutableMap<G, F><!>
actual typealias C6<H> = MutableList<H>
<!IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C7<I> = MutableList<out I><!>
<!IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C8<<!UNUSED_TYPEALIAS_PARAMETER!>J<!>> = MutableList<*><!>
<!IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C9<K> = MutableList<in K><!>
<!ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C7<I> = MutableList<out I><!>
<!ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C8<<!UNUSED_TYPEALIAS_PARAMETER!>J<!>> = MutableList<*><!>
<!ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE!>actual typealias C9<K> = MutableList<in K><!>
typealias Tmp<K> = MutableList<K>
<!IMPL_TYPE_ALIAS_NOT_TO_CLASS!>actual typealias C10<L> = Tmp<L><!>
<!ACTUAL_TYPE_ALIAS_NOT_TO_CLASS!>actual typealias C10<L> = Tmp<L><!>
compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt
Vendored
+9 -9
View File
@@ -2,28 +2,28 @@
// MODULE: m1-common
// FILE: common.kt
expect class Foo(
<!HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER!>val constructorProperty: String<!>,
<!EXPECTED_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER!>val constructorProperty: String<!>,
constructorParameter: String
) {
<!HEADER_DECLARATION_WITH_BODY!>init<!> {
<!EXPECTED_DECLARATION_WITH_BODY!>init<!> {
<!UNUSED_EXPRESSION, UNUSED_EXPRESSION!>"no"<!>
}
<!HEADER_DECLARATION_WITH_BODY!>constructor(s: String)<!> {
<!EXPECTED_DECLARATION_WITH_BODY!>constructor(s: String)<!> {
<!UNUSED_EXPRESSION!>"no"<!>
}
constructor() : <!HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("no")
constructor() : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("no")
val prop: String = <!HEADER_PROPERTY_INITIALIZER!>"no"<!>
val prop: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
var getSet: String
<!HEADER_DECLARATION_WITH_BODY!>get()<!> = "no"
<!HEADER_DECLARATION_WITH_BODY!>set(value)<!> {}
<!EXPECTED_DECLARATION_WITH_BODY!>get()<!> = "no"
<!EXPECTED_DECLARATION_WITH_BODY!>set(value)<!> {}
fun defaultArg(<!HEADER_DECLARATION_WITH_DEFAULT_PARAMETER!>value: String = "no"<!>)
fun defaultArg(<!EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER!>value: String = "no"<!>)
<!HEADER_DECLARATION_WITH_BODY!>fun functionWithBody(x: Int): Int<!> {
<!EXPECTED_DECLARATION_WITH_BODY!>fun functionWithBody(x: Int): Int<!> {
return x + 1
}
}
compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt
Vendored
+3 -3
View File
@@ -4,7 +4,7 @@
expect class B {
class N {
<!HEADER_DECLARATION_WITH_BODY, JVM:HEADER_DECLARATION_WITH_BODY!>fun body()<!> {}
<!EXPECTED_DECLARATION_WITH_BODY, JVM:EXPECTED_DECLARATION_WITH_BODY!>fun body()<!> {}
<!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> fun extraHeader()
}
}
@@ -39,8 +39,8 @@ actual class C {
actual inner class I
}
actual class <!HEADER_CLASS_MEMBERS_ARE_NOT_IMPLEMENTED!>D<!>
actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>D<!>
actual class E {
class <!IMPL_MISSING!>N<!>
class <!ACTUAL_MISSING!>N<!>
}
compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ expect class Foo {
// FILE: jvm.kt
actual class Foo {
<!IMPL_MISSING!>fun bar(): String<!> = "bar"
<!ACTUAL_MISSING!>fun bar(): String<!> = "bar"
}
compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt
Vendored
+2 -2
View File
@@ -23,7 +23,7 @@ fun foo() {
// FILE: jvm.kt
class Outer actual constructor() {
actual class <!IMPLEMENTATION_WITHOUT_HEADER!>Nested<!>
actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
<!WRONG_MODIFIER_TARGET!>actual<!> init {}
}
@@ -31,5 +31,5 @@ class Outer actual constructor() {
fun foo() {
<!WRONG_MODIFIER_TARGET!>actual<!> fun localFun() {}
<!WRONG_MODIFIER_TARGET!>actual<!> var <!UNUSED_VARIABLE!>x<!> = 42
<!WRONG_MODIFIER_TARGET!>actual<!> class <!IMPLEMENTATION_WITHOUT_HEADER!>Bar<!>
<!WRONG_MODIFIER_TARGET!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Bar<!>
}
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.kt
Vendored
+1 -1
View File
@@ -2,4 +2,4 @@
// MODULE: m1-common
// FILE: common.kt
expect fun foo(x: Int, <!HEADER_DECLARATION_WITH_DEFAULT_PARAMETER!>y: String = ""<!>)
expect fun foo(x: Int, <!EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER!>y: String = ""<!>)
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt
Vendored
+3 -3
View File
@@ -3,16 +3,16 @@
// FILE: common.kt
package common
<!JS:HEADER_WITHOUT_IMPLEMENTATION, JVM:HEADER_WITHOUT_IMPLEMENTATION!>expect fun foo()<!>
<!JS:NO_ACTUAL_FOR_EXPECT, JVM:NO_ACTUAL_FOR_EXPECT!>expect fun foo()<!>
// MODULE: m2-jvm(m1-common)
// FILE: jvm.kt
package jvm
<!IMPLEMENTATION_WITHOUT_HEADER!>actual fun foo()<!> {}
<!ACTUAL_WITHOUT_EXPECT!>actual fun foo()<!> {}
// MODULE: m3-js(m1-common)
// FILE: js.kt
package js
<!IMPLEMENTATION_WITHOUT_HEADER!>actual fun foo()<!> {}
<!ACTUAL_WITHOUT_EXPECT!>actual fun foo()<!> {}
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerDeclarationWithBody.kt
Vendored
+2 -2
View File
@@ -4,6 +4,6 @@
<!CONFLICTING_OVERLOADS!>expect fun foo()<!>
<!CONFLICTING_OVERLOADS, HEADER_DECLARATION_WITH_BODY!>expect fun foo()<!> {}
<!CONFLICTING_OVERLOADS, EXPECTED_DECLARATION_WITH_BODY!>expect fun foo()<!> {}
<!HEADER_DECLARATION_WITH_BODY!>expect fun bar()<!> {}
<!EXPECTED_DECLARATION_WITH_BODY!>expect fun bar()<!> {}
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.kt
Vendored
+1 -1
View File
@@ -9,4 +9,4 @@ expect fun foo()
<!NON_MEMBER_FUNCTION_NO_BODY!>actual fun foo()<!>
<!NON_MEMBER_FUNCTION_NO_BODY, IMPLEMENTATION_WITHOUT_HEADER!>actual fun bar()<!>
<!NON_MEMBER_FUNCTION_NO_BODY, ACTUAL_WITHOUT_EXPECT!>actual fun bar()<!>
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implWithoutHeader.kt
Vendored
+1 -1
View File
@@ -2,4 +2,4 @@
// MODULE: m1-jvm
// FILE: jvm.kt
<!IMPLEMENTATION_WITHOUT_HEADER!>actual fun foo()<!> { }
<!ACTUAL_WITHOUT_EXPECT!>actual fun foo()<!> { }
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ expect fun nonInlineFun()
// MODULE: m2-jvm(m1-common)
// FILE: jvm.kt
<!IMPLEMENTATION_WITHOUT_HEADER!>actual fun inlineFun()<!> { }
<!ACTUAL_WITHOUT_EXPECT!>actual fun inlineFun()<!> { }
actual fun nonInlineFun() { }
// MODULE: m3-js(m1-common)
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.kt
Vendored
+4 -4
View File
@@ -18,10 +18,10 @@ expect fun f8(vararg x: Any)
// FILE: jvm.kt
actual inline fun f1(noinline s: () -> String) {}
<!IMPLEMENTATION_WITHOUT_HEADER!>actual inline fun f2(noinline s: () -> String)<!> {}
<!ACTUAL_WITHOUT_EXPECT!>actual inline fun f2(noinline s: () -> String)<!> {}
actual inline fun f3(s: () -> String) {}
actual inline fun f4(crossinline s: () -> String) {}
<!IMPLEMENTATION_WITHOUT_HEADER!>actual inline fun f5(crossinline s: () -> String)<!> {}
<!ACTUAL_WITHOUT_EXPECT!>actual inline fun f5(crossinline s: () -> String)<!> {}
actual inline fun f6(s: () -> String) {}
<!IMPLEMENTATION_WITHOUT_HEADER!>actual fun f7(vararg x: Any)<!> {}
<!IMPLEMENTATION_WITHOUT_HEADER!>actual fun f8(x: Any)<!> {}
<!ACTUAL_WITHOUT_EXPECT!>actual fun f7(vararg x: Any)<!> {}
<!ACTUAL_WITHOUT_EXPECT!>actual fun f8(x: Any)<!> {}
compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt
Vendored
+5 -5
View File
@@ -17,14 +17,14 @@ expect var varWithPlatformGetSet: String
<!WRONG_MODIFIER_TARGET!>expect<!> get
<!WRONG_MODIFIER_TARGET!>expect<!> set
expect val backingFieldVal: String = <!HEADER_PROPERTY_INITIALIZER!>"no"<!>
expect var backingFieldVar: String = <!HEADER_PROPERTY_INITIALIZER!>"no"<!>
expect val backingFieldVal: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
expect var backingFieldVar: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
expect val customAccessorVal: String
<!HEADER_DECLARATION_WITH_BODY!>get()<!> = "no"
<!EXPECTED_DECLARATION_WITH_BODY!>get()<!> = "no"
expect var customAccessorVar: String
<!HEADER_DECLARATION_WITH_BODY!>get()<!> = "no"
<!HEADER_DECLARATION_WITH_BODY!>set(value)<!> {}
<!EXPECTED_DECLARATION_WITH_BODY!>get()<!> = "no"
<!EXPECTED_DECLARATION_WITH_BODY!>set(value)<!> {}
expect <!CONST_VAL_WITHOUT_INITIALIZER!>const<!> val constVal: Int
compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
<!UNSUPPORTED_FEATURE!>expect<!> fun foo1()
<!UNSUPPORTED_FEATURE!>expect<!> val bar1 = <!HEADER_PROPERTY_INITIALIZER!>42<!>
<!UNSUPPORTED_FEATURE!>expect<!> val bar1 = <!EXPECTED_PROPERTY_INITIALIZER!>42<!>
<!UNSUPPORTED_FEATURE!>expect<!> class Baz1
<!UNSUPPORTED_FEATURE!>actual<!> fun foo2() = 42
compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt
+1 -1
View File
@@ -344,7 +344,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
val dependencies = moduleDescriptor.testOnly_AllDependentModules
// TODO: diagnostics on common code reported during the platform module analysis should be distinguished somehow
// E.g. "<!JVM:IMPLEMENTATION_WITHOUT_HEADER!>...<!>
// E.g. "<!JVM:ACTUAL_WITHOUT_EXPECT!>...<!>
val result = ArrayList<KtFile>(0)
for (dependency in dependencies) {
if (dependency.getCapability(MultiTargetPlatform.CAPABILITY) == MultiTargetPlatform.Common) {
idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
+3 -3
View File
@@ -175,12 +175,12 @@ public class IdeErrorMessages {
MAP.put(EXPERIMENTAL_FEATURE_WARNING, "<html>{0}</html>", new LanguageFeatureMessageRenderer(LanguageFeatureMessageRenderer.Type.WARNING, true));
MAP.put(EXPERIMENTAL_FEATURE_ERROR, "<html>{0}</html>", new LanguageFeatureMessageRenderer(LanguageFeatureMessageRenderer.Type.ERROR, true));
MAP.put(HEADER_WITHOUT_IMPLEMENTATION, "<html>''header'' {0} has no implementation in module{1}{2}</html>", DECLARATION_NAME_WITH_KIND,
MAP.put(NO_ACTUAL_FOR_EXPECT, "<html>''header'' {0} has no implementation in module{1}{2}</html>", DECLARATION_NAME_WITH_KIND,
PLATFORM, new PlatformIncompatibilityDiagnosticRenderer(IdeMultiplatformDiagnosticRenderingMode.INSTANCE));
MAP.put(IMPLEMENTATION_WITHOUT_HEADER, "<html>''impl'' {0} has no corresponding ''header'' declaration{1}</html>", DECLARATION_NAME_WITH_KIND,
MAP.put(ACTUAL_WITHOUT_EXPECT, "<html>''impl'' {0} has no corresponding ''header'' declaration{1}</html>", DECLARATION_NAME_WITH_KIND,
new PlatformIncompatibilityDiagnosticRenderer(IdeMultiplatformDiagnosticRenderingMode.INSTANCE));
MAP.put(HEADER_CLASS_MEMBERS_ARE_NOT_IMPLEMENTED, "<html>''impl'' class ''{0}'' has no implementation of ''header'' class members:{1}</html>",
MAP.put(NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS, "<html>''impl'' class ''{0}'' has no implementation of ''header'' class members:{1}</html>",
NAME, new IncompatibleHeaderImplClassScopesRenderer(IdeMultiplatformDiagnosticRenderingMode.INSTANCE));
MAP.setImmutable();
idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
+2 -2
View File
@@ -477,8 +477,8 @@ class QuickFixRegistrar : QuickFixContributor {
OVERLOADS_LOCAL.registerFactory(RemoveAnnotationFix.JvmOverloads)
OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS.registerFactory(RemoveAnnotationFix.JvmOverloads)
HEADER_WITHOUT_IMPLEMENTATION.registerFactory(CreateActualFix)
IMPL_MISSING.registerFactory(AddModifierFix.createFactory(KtTokens.ACTUAL_KEYWORD))
NO_ACTUAL_FOR_EXPECT.registerFactory(CreateActualFix)
ACTUAL_MISSING.registerFactory(AddModifierFix.createFactory(KtTokens.ACTUAL_KEYWORD))
CAST_NEVER_SUCCEEDS.registerFactory(ReplacePrimitiveCastWithNumberConversionFix)
idea/src/org/jetbrains/kotlin/idea/quickfix/createImpl/CreateActualFix.kt
+1 -1
View File
@@ -134,7 +134,7 @@ sealed class CreateActualFix<out D : KtNamedDeclaration>(
companion object : KotlinSingleIntentionActionFactory() {
override fun createAction(diagnostic: Diagnostic): IntentionAction? {
val d = DiagnosticFactory.cast(diagnostic, Errors.HEADER_WITHOUT_IMPLEMENTATION)
val d = DiagnosticFactory.cast(diagnostic, Errors.NO_ACTUAL_FOR_EXPECT)
val declaration = d.psiElement as? KtNamedDeclaration ?: return null
val compatibility = d.c
if (compatibility.isNotEmpty()) return null
idea/testData/multiModuleHighlighting/multiplatform/basic/common/common.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
expect class <error descr="[HEADER_WITHOUT_IMPLEMENTATION] 'header' class 'My' has no implementation in module jvm for JVM">My</error> {
expect class <error descr="[NO_ACTUAL_FOR_EXPECT] 'header' class 'My' has no implementation in module jvm for JVM">My</error> {
}
idea/testData/multiModuleHighlighting/multiplatform/basic/jvm/jvm.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
actual class <error descr="[IMPLEMENTATION_WITHOUT_HEADER] 'impl' class 'Your' has no corresponding 'header' declaration">Your</error> {
actual class <error descr="[ACTUAL_WITHOUT_EXPECT] 'impl' class 'Your' has no corresponding 'header' declaration">Your</error> {
}
expect class <error descr="[HEADER_WITHOUT_IMPLEMENTATION] 'header' class 'His' has no implementation in module jvm for JVM">His</error> {
expect class <error descr="[NO_ACTUAL_FOR_EXPECT] 'header' class 'His' has no implementation in module jvm for JVM">His</error> {
}
idea/testData/multiModuleHighlighting/multiplatform/headerWithoutImplForBoth/common/common.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
expect class <error descr="[HEADER_WITHOUT_IMPLEMENTATION] 'header' class 'My' has no implementation in module js for JS"><error descr="[HEADER_WITHOUT_IMPLEMENTATION] 'header' class 'My' has no implementation in module jvm for JVM">My</error></error> {
expect class <error descr="[NO_ACTUAL_FOR_EXPECT] 'header' class 'My' has no implementation in module js for JS"><error descr="[NO_ACTUAL_FOR_EXPECT] 'header' class 'My' has no implementation in module jvm for JVM">My</error></error> {
}
idea/testData/multiModuleHighlighting/multiplatform/suppressHeaderWithoutImpl/common/common.kt
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
// See KT-15601
@Suppress("HEADER_WITHOUT_IMPLEMENTATION")
@Suppress("NO_ACTUAL_FOR_EXPECT")
expect interface Event
@Suppress("SOMETHING_WRONG")
expect class <error descr="[HEADER_WITHOUT_IMPLEMENTATION] 'header' class 'Wrong' has no implementation in module jvm for JVM">Wrong</error>
expect class <error descr="[NO_ACTUAL_FOR_EXPECT] 'header' class 'Wrong' has no implementation in module jvm for JVM">Wrong</error>
libraries/kotlin.test/common/src/main/kotlin/org/junit/Test.kt
+1 -1
View File
@@ -1,4 +1,4 @@
package org.junit
@Suppress("HEADER_WITHOUT_IMPLEMENTATION")
@Suppress("NO_ACTUAL_FOR_EXPECT")
header annotation class Test