diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java index 66ee82269b9..93105694059 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java @@ -78,7 +78,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem super(containingDeclaration, null, Annotations.Companion.getEMPTY(), Modality.FINAL, Visibilities.LOCAL, original.isVar(), Name.identifier("access$" + nameSuffix), Kind.DECLARATION, SourceElement.NO_SOURCE, /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, /* isImpl = */ false, /* isExternal = */ false); + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false); this.calleeDescriptor = original; this.superCallTarget = superCallTarget; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java index c3fa3936c5c..a20795fd5f3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java @@ -112,7 +112,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class } @Override - public boolean isPlatform() { + public boolean isHeader() { return false; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java index f6adfc13620..af4cb608f40 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java @@ -101,7 +101,7 @@ public class PackageCodegenImpl implements PackageCodegen { List classOrObjects = new ArrayList(); for (KtDeclaration declaration : file.getDeclarations()) { - if (declaration.hasModifier(KtTokens.PLATFORM_KEYWORD)) continue; + if (declaration.hasModifier(KtTokens.HEADER_KEYWORD)) continue; if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction || declaration instanceof KtTypeAlias) { generatePackagePart = true; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java index 977553e675f..2f878ecd1bb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java @@ -92,7 +92,7 @@ public class PackagePartCodegen extends MemberCodegen { @Override protected void generateBody() { for (KtDeclaration declaration : element.getDeclarations()) { - if (declaration.hasModifier(KtTokens.PLATFORM_KEYWORD)) continue; + if (declaration.hasModifier(KtTokens.HEADER_KEYWORD)) continue; if (declaration instanceof KtNamedFunction || declaration instanceof KtProperty || declaration instanceof KtTypeAlias) { genSimpleMember(declaration); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt index e04f9e69d41..6be40b2f7c7 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt @@ -73,7 +73,7 @@ object PackagePartClassUtils { (it is KtProperty || it is KtNamedFunction || it is KtScript || - it is KtTypeAlias) && !it.hasModifier(KtTokens.PLATFORM_KEYWORD) + it is KtTypeAlias) && !it.hasModifier(KtTokens.HEADER_KEYWORD) } @JvmStatic fun getFilePartShortName(fileName: String): String = diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt index db4ef9c6d70..f9d06fc0afc 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.platform.JavaToKotlinClassMap import org.jetbrains.kotlin.resolve.PlatformConfigurator import org.jetbrains.kotlin.resolve.calls.checkers.ReifiedTypeParameterSubstitutionChecker import org.jetbrains.kotlin.resolve.checkers.MissingDependencyClassChecker -import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker +import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker import org.jetbrains.kotlin.resolve.jvm.JvmOverloadFilter import org.jetbrains.kotlin.resolve.jvm.JvmTypeSpecificityComparator import org.jetbrains.kotlin.resolve.jvm.RuntimeAssertionsTypeChecker @@ -47,7 +47,7 @@ object JvmPlatformConfigurator : PlatformConfigurator( JvmSyntheticApplicabilityChecker(), StrictfpApplicabilityChecker(), AdditionalBuiltInsMemberOverrideDeclarationChecker, - PlatformImplDeclarationChecker() + HeaderImplDeclarationChecker() ), additionalCallCheckers = listOf( diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt index f162e6a530e..e41edd906d3 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt @@ -280,7 +280,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager, private val l source: SourceElement ) : SyntheticJavaPropertyDescriptor, PropertyDescriptorImpl( containingDeclaration, original, annotations, modality, visibility, isVar, name, kind, source, - /* lateInit = */ false, /* isConst = */ false, /* isPlatform = */ false, /* isImpl = */ false, /* isExternal = */ false + /* lateInit = */ false, /* isConst = */ false, /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ) { override var getMethod: FunctionDescriptor by Delegates.notNull() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt index f65226e5a60..4fb813acf20 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt @@ -637,7 +637,7 @@ class ControlFlowInformationProvider private constructor( is KtPrimaryConstructor -> if (!element.hasValOrVar()) { val containingClass = owner.getContainingClassOrObject() val containingClassDescriptor = trace.get(DECLARATION_TO_DESCRIPTOR, containingClass) as? ClassDescriptor - if (!DescriptorUtils.isAnnotationClass(containingClassDescriptor) && containingClassDescriptor?.isPlatform == false && + if (!DescriptorUtils.isAnnotationClass(containingClassDescriptor) && containingClassDescriptor?.isHeader == false && !DescriptorUtils.isEffectivelyExternal(containingClassDescriptor) ) { report(UNUSED_PARAMETER.on(element, variableDescriptor), ctxt) @@ -653,7 +653,7 @@ class ControlFlowInformationProvider private constructor( if (isMain || functionDescriptor.isOverridableOrOverrides || owner.hasModifier(KtTokens.OVERRIDE_KEYWORD) - || functionDescriptor.isPlatform || functionDescriptor.isImpl + || functionDescriptor.isHeader || functionDescriptor.isImpl || DescriptorUtils.isEffectivelyExternal(functionDescriptor) || OperatorNameConventions.GET_VALUE == functionName || OperatorNameConventions.SET_VALUE == functionName diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 6853074d6d0..1af83675532 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.VarianceConflictDiagnosticData; import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.calls.tower.WrongResolutionToClassifier; -import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker; +import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker; import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData; import org.jetbrains.kotlin.types.KotlinType; @@ -499,11 +499,11 @@ public interface Errors { // Multi-platform projects - DiagnosticFactory0 PLATFORM_DECLARATION_WITH_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); - DiagnosticFactory0 PLATFORM_DECLARATION_WITH_DEFAULT_PARAMETER = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 PLATFORM_CLASS_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 PLATFORM_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 PLATFORM_PROPERTY_INITIALIZER = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 HEADER_DECLARATION_WITH_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); + DiagnosticFactory0 HEADER_DECLARATION_WITH_DEFAULT_PARAMETER = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 HEADER_PROPERTY_INITIALIZER = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 IMPL_TYPE_ALIAS_NOT_TO_CLASS = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); DiagnosticFactory0 IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); @@ -511,9 +511,9 @@ public interface Errors { DiagnosticFactory0 IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); DiagnosticFactory2>> PLATFORM_DECLARATION_WITHOUT_DEFINITION = + Map>> HEADER_WITHOUT_IMPLEMENTATION = DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE); - DiagnosticFactory0 PLATFORM_DEFINITION_WITHOUT_DECLARATION = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 IMPLEMENTATION_WITHOUT_HEADER = DiagnosticFactory0.create(ERROR); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 839ff570fd0..bf7b37d3392 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -259,19 +259,19 @@ public class DefaultErrorMessages { MAP.put(USELESS_VARARG_ON_PARAMETER, "Vararg on this parameter is useless"); MAP.put(MULTIPLE_VARARG_PARAMETERS, "Multiple vararg-parameters are prohibited"); - MAP.put(PLATFORM_DECLARATION_WITH_BODY, "Platform declaration must not have a body"); - MAP.put(PLATFORM_DECLARATION_WITH_DEFAULT_PARAMETER, "Platform declaration cannot have parameters with default values"); - MAP.put(PLATFORM_CLASS_CONSTRUCTOR_DELEGATION_CALL, "Explicit delegation call for constructor of a platform class is not allowed"); - MAP.put(PLATFORM_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER, "Platform class constructor cannot have a property parameter"); - MAP.put(PLATFORM_PROPERTY_INITIALIZER, "Platform property cannot have an initializer"); + 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_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 = Bar'"); - MAP.put(PLATFORM_DECLARATION_WITHOUT_DEFINITION, "No definition is found for platform declaration ''{0}''{1}", NAME, PlatformIncompatibilityDiagnosticRenderer.INSTANCE); - MAP.put(PLATFORM_DEFINITION_WITHOUT_DECLARATION, "Modifier 'impl' is only applicable to members that are initially declared in platform-independent code"); + MAP.put(HEADER_WITHOUT_IMPLEMENTATION, "No implementation is found for header declaration ''{0}''{1}", NAME, PlatformIncompatibilityDiagnosticRenderer.INSTANCE); + MAP.put(IMPLEMENTATION_WITHOUT_HEADER, "Modifier 'impl' is only applicable to members that are initially declared in platform-independent code"); 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"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt index b434b3b05e7..86465e1f622 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt @@ -18,14 +18,14 @@ package org.jetbrains.kotlin.diagnostics.rendering import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.MemberDescriptor -import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker +import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker object PlatformIncompatibilityDiagnosticRenderer : - DiagnosticParameterRenderer>> { + DiagnosticParameterRenderer>> { private val INDENTATION_UNIT = " " override fun render( - obj: Map>, + obj: Map>, renderingContext: RenderingContext ): String { if (obj.isEmpty()) return "" @@ -39,7 +39,7 @@ object PlatformIncompatibilityDiagnosticRenderer : } private fun StringBuilder.render( - map: Map>, + map: Map>, indent: String, renderDescriptor: (DeclarationDescriptor) -> String ) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java index 31339a3b3c9..c49e58f34ca 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java @@ -189,7 +189,7 @@ public interface KtTokens { KtModifierKeywordToken COROUTINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("coroutine"); KtModifierKeywordToken SUSPEND_KEYWORD = KtModifierKeywordToken.softKeywordModifier("suspend"); - KtModifierKeywordToken PLATFORM_KEYWORD = KtModifierKeywordToken.softKeywordModifier("platform"); + KtModifierKeywordToken HEADER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("header"); KtModifierKeywordToken IMPL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("impl"); TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD, @@ -212,7 +212,7 @@ public interface KtTokens { LATEINIT_KEYWORD, DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD, CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD, - COROUTINE_KEYWORD, SUSPEND_KEYWORD, PLATFORM_KEYWORD, IMPL_KEYWORD + COROUTINE_KEYWORD, SUSPEND_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD ); /* @@ -226,7 +226,7 @@ public interface KtTokens { PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD, COMPANION_KEYWORD, SEALED_KEYWORD, LATEINIT_KEYWORD, DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD, - CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD, COROUTINE_KEYWORD, SUSPEND_KEYWORD, PLATFORM_KEYWORD, IMPL_KEYWORD + CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD, COROUTINE_KEYWORD, SUSPEND_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD }; TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt index 6ed1bbb8949..84c51e71c7c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt @@ -73,7 +73,7 @@ class SyntheticClassOrObjectDescriptor( override fun isCompanionObject() = isCompanionObject override fun isInner() = false override fun isData() = false - override fun isPlatform() = false + override fun isHeader() = false override fun isImpl() = false override fun getCompanionObjectDescriptor() = null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index ca1db1fa675..a776c83929d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -169,8 +169,8 @@ public class BodyResolver { @NotNull KtSecondaryConstructor constructor, @NotNull ClassConstructorDescriptor descriptor ) { - if (descriptor.isPlatform()) { - // For platform classes, we do not resolve constructor delegation calls because they are prohibited + if (descriptor.isHeader()) { + // For header classes, we do not resolve constructor delegation calls because they are prohibited return DataFlowInfo.Companion.getEMPTY(); } @@ -367,7 +367,7 @@ public class BodyResolver { descriptor.getUnsubstitutedPrimaryConstructor() != null && superClass.getKind() != ClassKind.INTERFACE && !superClass.getConstructors().isEmpty() && - !descriptor.isPlatform() && + !descriptor.isHeader() && !ErrorUtils.isError(superClass) ) { trace.report(SUPERTYPE_NOT_INITIALIZED.on(specifier)); @@ -562,8 +562,8 @@ public class BodyResolver { if (classDescriptor.getConstructors().isEmpty()) { trace.report(ANONYMOUS_INITIALIZER_IN_INTERFACE.on(anonymousInitializer)); } - if (classDescriptor.isPlatform()) { - trace.report(PLATFORM_DECLARATION_WITH_BODY.on(anonymousInitializer)); + if (classDescriptor.isHeader()) { + trace.report(HEADER_DECLARATION_WITH_BODY.on(anonymousInitializer)); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt index 1566b9c4302..acd84bcff27 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt @@ -78,12 +78,12 @@ class DeclarationResolver( for ((fqName, declarationsOrPackageDirectives) in topLevelFqNames.asMap()) { if (fqName.isRoot) continue - // TODO: report error on platform class and impl val, or vice versa - val (platform, impl) = + // TODO: report error on header class and impl val, or vice versa + val (header, impl) = getTopLevelDescriptorsByFqName(topLevelDescriptorProvider, fqName, NoLookupLocation.WHEN_CHECK_REDECLARATIONS) - .partition { it is MemberDescriptor && it.isPlatform } + .partition { it is MemberDescriptor && it.isHeader } - for (descriptors in listOf(platform, impl)) { + for (descriptors in listOf(header, impl)) { if (descriptors.size > 1) { for (directive in declarationsOrPackageDirectives) { val reportAt = (directive as? KtPackageDirective)?.nameIdentifier ?: directive diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt index 3b87e824c1d..5db50e6dacb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt @@ -264,20 +264,20 @@ class DeclarationsChecker( identifierChecker.checkDeclaration(declaration, trace) checkVarargParameters(trace, constructorDescriptor) checkConstructorVisibility(constructorDescriptor, declaration) - checkPlatformClassConstructor(constructorDescriptor, declaration) + checkHeaderClassConstructor(constructorDescriptor, declaration) } - private fun checkPlatformClassConstructor(constructorDescriptor: ClassConstructorDescriptor, declaration: KtConstructor<*>) { - if (!constructorDescriptor.isPlatform) return + private fun checkHeaderClassConstructor(constructorDescriptor: ClassConstructorDescriptor, declaration: KtConstructor<*>) { + if (!constructorDescriptor.isHeader) return if (declaration.hasBody()) { - trace.report(PLATFORM_DECLARATION_WITH_BODY.on(declaration)) + trace.report(HEADER_DECLARATION_WITH_BODY.on(declaration)) } if (declaration is KtPrimaryConstructor && !DescriptorUtils.isAnnotationClass(constructorDescriptor.constructedClass)) { for (parameter in declaration.valueParameters) { if (parameter.hasValOrVar()) { - trace.report(PLATFORM_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER.on(parameter)) + trace.report(HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER.on(parameter)) } } } @@ -285,7 +285,7 @@ class DeclarationsChecker( if (declaration is KtSecondaryConstructor) { val delegationCall = declaration.getDelegationCall() if (!delegationCall.isImplicit) { - trace.report(PLATFORM_CLASS_CONSTRUCTOR_DELEGATION_CALL.on(delegationCall)) + trace.report(HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL.on(delegationCall)) } } } @@ -703,13 +703,13 @@ class DeclarationsChecker( val initializer = property.initializer val delegate = property.delegate - val isPlatform = propertyDescriptor.isPlatform + val isHeader = propertyDescriptor.isHeader if (initializer != null) { if (inTrait) { trace.report(PROPERTY_INITIALIZER_IN_INTERFACE.on(initializer)) } - else if (isPlatform) { - trace.report(PLATFORM_PROPERTY_INITIALIZER.on(initializer)) + else if (isHeader) { + trace.report(HEADER_PROPERTY_INITIALIZER.on(initializer)) } else if (!backingFieldRequired) { trace.report(PROPERTY_INITIALIZER_NO_BACKING_FIELD.on(initializer)) @@ -726,7 +726,7 @@ class DeclarationsChecker( else { val isUninitialized = trace.bindingContext.get(BindingContext.IS_UNINITIALIZED, propertyDescriptor) ?: false val isExternal = DescriptorUtils.isEffectivelyExternal(propertyDescriptor) - if (backingFieldRequired && !inTrait && !propertyDescriptor.isLateInit && !isPlatform && isUninitialized && !isExternal) { + if (backingFieldRequired && !inTrait && !propertyDescriptor.isLateInit && !isHeader && isUninitialized && !isExternal) { if (containingDeclaration !is ClassDescriptor || hasAccessorImplementation) { trace.report(MUST_BE_INITIALIZED.on(property)) } @@ -766,7 +766,7 @@ class DeclarationsChecker( if (containingDescriptor is ClassDescriptor) { val inInterface = containingDescriptor.kind == ClassKind.INTERFACE - val isPlatformClass = containingDescriptor.isPlatform + val isHeaderClass = containingDescriptor.isHeader if (hasAbstractModifier && !classCanHaveAbstractMembers(containingDescriptor)) { trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.name.asString(), containingDescriptor)) } @@ -782,29 +782,29 @@ class DeclarationsChecker( trace.report(REDUNDANT_OPEN_IN_INTERFACE.on(function)) } } - if (!hasBody && !hasAbstractModifier && !hasExternalModifier && !inInterface && !isPlatformClass) { + if (!hasBody && !hasAbstractModifier && !hasExternalModifier && !inInterface && !isHeaderClass) { trace.report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)) } } else /* top-level only */ { - if (!function.hasBody() && !hasAbstractModifier && !hasExternalModifier && !functionDescriptor.isPlatform) { + if (!function.hasBody() && !hasAbstractModifier && !hasExternalModifier && !functionDescriptor.isHeader) { trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)) } } - if (functionDescriptor.isPlatform) { - checkPlatformFunction(function) + if (functionDescriptor.isHeader) { + checkHeaderFunction(function) } } - private fun checkPlatformFunction(function: KtNamedFunction) { + private fun checkHeaderFunction(function: KtNamedFunction) { if (function.hasBody()) { - trace.report(PLATFORM_DECLARATION_WITH_BODY.on(function)) + trace.report(HEADER_DECLARATION_WITH_BODY.on(function)) } for (parameter in function.valueParameters) { if (parameter.hasDefaultValue()) { - trace.report(PLATFORM_DECLARATION_WITH_DEFAULT_PARAMETER.on(parameter)) + trace.report(HEADER_DECLARATION_WITH_DEFAULT_PARAMETER.on(parameter)) } } } @@ -858,8 +858,8 @@ class DeclarationsChecker( accessorDescriptor: PropertyAccessorDescriptor? ) { if (accessor == null || accessorDescriptor == null) return - if (propertyDescriptor.isPlatform && accessor.hasBody()) { - trace.report(PLATFORM_DECLARATION_WITH_BODY.on(accessor)) + if (propertyDescriptor.isHeader && accessor.hasBody()) { + trace.report(HEADER_DECLARATION_WITH_BODY.on(accessor)) } val accessorModifierList = accessor.modifierList ?: return diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index cab0b44535e..454e83830a8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -820,8 +820,8 @@ public class DescriptorResolver { KotlinSourceElementKt.toSourceElement(property), modifierList != null && modifierList.hasModifier(KtTokens.LATEINIT_KEYWORD), modifierList != null && modifierList.hasModifier(KtTokens.CONST_KEYWORD), - modifierList != null && modifierList.hasModifier(KtTokens.PLATFORM_KEYWORD) || - containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).isPlatform(), + modifierList != null && modifierList.hasModifier(KtTokens.HEADER_KEYWORD) || + containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).isHeader(), modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD), modifierList != null && modifierList.hasModifier(KtTokens.EXTERNAL_KEYWORD) ); @@ -1141,7 +1141,7 @@ public class DescriptorResolver { KotlinSourceElementKt.toSourceElement(parameter), /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index 0cdafdd53d2..f0e311a1f08 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -186,8 +186,8 @@ class FunctionDescriptorResolver( functionDescriptor.isInline = function.hasModifier(KtTokens.INLINE_KEYWORD) functionDescriptor.isTailrec = function.hasModifier(KtTokens.TAILREC_KEYWORD) functionDescriptor.isSuspend = function.hasModifier(KtTokens.SUSPEND_KEYWORD) - functionDescriptor.isPlatform = function.hasModifier(KtTokens.PLATFORM_KEYWORD) || - containingDescriptor is ClassDescriptor && containingDescriptor.isPlatform + functionDescriptor.isHeader = function.hasModifier(KtTokens.HEADER_KEYWORD) || + containingDescriptor is ClassDescriptor && containingDescriptor.isHeader functionDescriptor.isImpl = function.hasModifier(KtTokens.IMPL_KEYWORD) receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.annotations) } @@ -299,8 +299,8 @@ class FunctionDescriptorResolver( isPrimary, declarationToTrace.toSourceElement() ) - if (classDescriptor.isPlatform) { - constructorDescriptor.isPlatform = true + if (classDescriptor.isHeader) { + constructorDescriptor.isHeader = true } if (classDescriptor.isImpl) { constructorDescriptor.isImpl = true diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt index bbe39457788..5eac75691a9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt @@ -147,7 +147,7 @@ class LocalVariableResolver( variable.toSourceElement(), /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt index 37aac7e8924..ebb4b8a4e18 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt @@ -90,7 +90,7 @@ object ModifierCheckerCore { CONST_KEYWORD to EnumSet.of(MEMBER_PROPERTY, TOP_LEVEL_PROPERTY), OPERATOR_KEYWORD to EnumSet.of(FUNCTION), INFIX_KEYWORD to EnumSet.of(FUNCTION), - PLATFORM_KEYWORD to EnumSet.of(TOP_LEVEL_FUNCTION, TOP_LEVEL_PROPERTY_WITHOUT_FIELD_OR_DELEGATE, CLASS_ONLY, OBJECT, INTERFACE, INNER_CLASS, ENUM_CLASS, ANNOTATION_CLASS), + HEADER_KEYWORD to EnumSet.of(TOP_LEVEL_FUNCTION, TOP_LEVEL_PROPERTY_WITHOUT_FIELD_OR_DELEGATE, CLASS_ONLY, OBJECT, INTERFACE, INNER_CLASS, ENUM_CLASS, ANNOTATION_CLASS), IMPL_KEYWORD to EnumSet.of(TOP_LEVEL_FUNCTION, MEMBER_FUNCTION, TOP_LEVEL_PROPERTY, MEMBER_PROPERTY, CONSTRUCTOR, CLASS_ONLY, OBJECT, INTERFACE, INNER_CLASS, ENUM_CLASS, ANNOTATION_CLASS, TYPEALIAS) ) @@ -98,7 +98,7 @@ object ModifierCheckerCore { COROUTINE_KEYWORD to LanguageFeature.Coroutines, SUSPEND_KEYWORD to LanguageFeature.Coroutines, INLINE_KEYWORD to LanguageFeature.InlineProperties, - PLATFORM_KEYWORD to LanguageFeature.MultiPlatformProjects, + HEADER_KEYWORD to LanguageFeature.MultiPlatformProjects, IMPL_KEYWORD to LanguageFeature.MultiPlatformProjects ) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt index 8e4c939f321..443c3c4e291 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt @@ -253,7 +253,7 @@ class OverloadResolver( if (isConstructorsOfDifferentRedeclaredClasses(member1, member2)) continue if (isTopLevelMainInDifferentFiles(member1, member2)) continue if (isDefinitionsForDifferentPlatforms(member1, member2)) continue - if (isPlatformDeclarationAndDefinition(member1, member2) || isPlatformDeclarationAndDefinition(member2, member1)) continue + if (isHeaderDeclarationAndDefinition(member1, member2) || isHeaderDeclarationAndDefinition(member2, member1)) continue if (!overloadChecker.isOverloadable(member1, member2)) { redeclarations.add(member1) @@ -283,9 +283,9 @@ class OverloadResolver( return file1 == null || file2 == null || file1 !== file2 } - private fun isPlatformDeclarationAndDefinition(declaration: DeclarationDescriptor, definition: DeclarationDescriptor): Boolean { - return declaration is MemberDescriptor && declaration.isPlatform && - definition is MemberDescriptor && !definition.isPlatform + private fun isHeaderDeclarationAndDefinition(declaration: DeclarationDescriptor, definition: DeclarationDescriptor): Boolean { + return declaration is MemberDescriptor && declaration.isHeader && + definition is MemberDescriptor && !definition.isHeader } private fun isDefinitionsForDifferentPlatforms(member1: DeclarationDescriptorNonRoot, member2: DeclarationDescriptorNonRoot): Boolean { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt index 579b611b05c..ef4484445dc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt @@ -98,7 +98,7 @@ class DynamicCallableDescriptors(storageManager: StorageManager, builtIns: Kotli SourceElement.NO_SOURCE, /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PlatformImplDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/HeaderImplDeclarationChecker.kt similarity index 94% rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PlatformImplDeclarationChecker.kt rename to compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/HeaderImplDeclarationChecker.kt index f6440f135c8..91f504a276e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PlatformImplDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/HeaderImplDeclarationChecker.kt @@ -28,8 +28,8 @@ import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils -import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker.Compatibility.Compatible -import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker.Compatibility.Incompatible +import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker.Compatibility.Compatible +import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker.Compatibility.Incompatible import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.resolve.descriptorUtil.module @@ -43,7 +43,7 @@ import org.jetbrains.kotlin.types.typeUtil.asTypeProjection import org.jetbrains.kotlin.utils.SmartList import org.jetbrains.kotlin.utils.keysToMap -class PlatformImplDeclarationChecker : DeclarationChecker { +class HeaderImplDeclarationChecker : DeclarationChecker { override fun check( declaration: KtDeclaration, descriptor: DeclarationDescriptor, @@ -55,16 +55,16 @@ class PlatformImplDeclarationChecker : DeclarationChecker { if (descriptor !is MemberDescriptor) return - if (descriptor.isPlatform && declaration.hasModifier(KtTokens.PLATFORM_KEYWORD)) { + if (descriptor.isHeader && declaration.hasModifier(KtTokens.HEADER_KEYWORD)) { val checkImpl = !languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformDoNotCheckImpl) - checkPlatformDeclarationHasDefinition(declaration, descriptor, diagnosticHolder, checkImpl) + checkHeaderDeclarationHasImplementation(declaration, descriptor, diagnosticHolder, checkImpl) } else if (descriptor.isImpl && declaration.hasModifier(KtTokens.IMPL_KEYWORD)) { - checkImplementationHasPlatformDeclaration(declaration, descriptor, diagnosticHolder) + checkImplementationHasHeaderDeclaration(declaration, descriptor, diagnosticHolder) } } - private fun checkPlatformDeclarationHasDefinition( + private fun checkHeaderDeclarationHasImplementation( reportOn: KtDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticSink, checkImpl: Boolean ) { val compatibility = when (descriptor) { @@ -92,17 +92,17 @@ class PlatformImplDeclarationChecker : DeclarationChecker { assert(compatibility.keys.all { it is Incompatible }) @Suppress("UNCHECKED_CAST") val incompatibility = compatibility as Map> - diagnosticHolder.report(Errors.PLATFORM_DECLARATION_WITHOUT_DEFINITION.on(reportOn, descriptor, incompatibility)) + diagnosticHolder.report(Errors.HEADER_WITHOUT_IMPLEMENTATION.on(reportOn, descriptor, incompatibility)) } } - private fun checkImplementationHasPlatformDeclaration( + private fun checkImplementationHasHeaderDeclaration( reportOn: KtDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticSink ) { fun ClassifierDescriptor.findDeclarationForClass(): ClassDescriptor? = findClassifiersFromTheSameModule().firstOrNull { declaration -> this != declaration && - declaration is ClassDescriptor && declaration.isPlatform && + declaration is ClassDescriptor && declaration.isHeader && areCompatibleClassifiers(declaration, this, checkImpl = false) == Compatible } as? ClassDescriptor @@ -116,7 +116,7 @@ class PlatformImplDeclarationChecker : DeclarationChecker { } candidates.any { declaration -> descriptor != declaration && - declaration.isPlatform && + declaration.isHeader && areCompatibleCallables(declaration, descriptor, checkImpl = false) == Compatible } } @@ -125,8 +125,8 @@ class PlatformImplDeclarationChecker : DeclarationChecker { } if (!hasDeclaration) { - // TODO: do not report this error for members which are "almost compatible" with some platform declarations - diagnosticHolder.report(Errors.PLATFORM_DEFINITION_WITHOUT_DECLARATION.on(reportOn.modifierList!!.getModifier(KtTokens.IMPL_KEYWORD)!!)) + // TODO: do not report this error for members which are "almost compatible" with some header declarations + diagnosticHolder.report(Errors.IMPLEMENTATION_WITHOUT_HEADER.on(reportOn.modifierList!!.getModifier(KtTokens.IMPL_KEYWORD)!!)) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt index cec502d16c2..43bfcaacd59 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt @@ -141,7 +141,7 @@ object InlineAnalyzerExtension : AnalyzerExtensions.AnalyzerExtension { if (InlineUtil.containsReifiedTypeParameters(functionDescriptor) || functionDescriptor.isInlineOnlyOrReified() || - functionDescriptor.isPlatform) return + functionDescriptor.isHeader) return val reportOn = function.modifierList?.getModifier(KtTokens.INLINE_KEYWORD) ?: function trace.report(Errors.NOTHING_TO_INLINE.on(reportOn, functionDescriptor)) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 4eb961f4da3..47cd4883bdf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -93,7 +93,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes private final ClassKind kind; private final boolean isInner; private final boolean isData; - private final boolean isPlatform; + private final boolean isHeader; private final boolean isImpl; private final Annotations annotations; @@ -177,7 +177,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes this.isInner = isInnerClass(modifierList) && !ModifiersChecker.isIllegalInner(this); this.isData = modifierList != null && modifierList.hasModifier(KtTokens.DATA_KEYWORD); - this.isPlatform = modifierList != null && modifierList.hasModifier(KtTokens.PLATFORM_KEYWORD); + this.isHeader = modifierList != null && modifierList.hasModifier(KtTokens.HEADER_KEYWORD); this.isImpl = modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD); // Annotation entries are taken from both own annotations (if any) and object literal annotations (if any) @@ -529,8 +529,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } @Override - public boolean isPlatform() { - return isPlatform; + public boolean isHeader() { + return isHeader; } @Override diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDescriptorWithExtraFlags.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDescriptorWithExtraFlags.kt index ed844a3c4fe..2a976d28606 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDescriptorWithExtraFlags.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDescriptorWithExtraFlags.kt @@ -40,11 +40,11 @@ class JvmPropertyDescriptorImpl( source: SourceElement, isLateInit: Boolean, isConst: Boolean, - isPlatform: Boolean, + isHeader: Boolean, isImpl: Boolean ) : JvmDescriptorWithExtraFlags, PropertyDescriptorImpl( containingDeclaration, original, annotations, modality, visibility, isVar, - name, kind, source, isLateInit, isConst, isPlatform, isImpl, /* isExternal = */ false + name, kind, source, isLateInit, isConst, isHeader, isImpl, /* isExternal = */ false ) { override fun createSubstitutedCopy( newOwner: DeclarationDescriptor, @@ -55,7 +55,7 @@ class JvmPropertyDescriptorImpl( ): PropertyDescriptorImpl = JvmPropertyDescriptorImpl( newOwner, original, annotations, newModality, newVisibility, extraFlags, isVar, name, kind, - SourceElement.NO_SOURCE, isLateInit, isConst, isPlatform, isImpl + SourceElement.NO_SOURCE, isLateInit, isConst, isHeader, isImpl ) companion object { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/KnownDescriptors.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/KnownDescriptors.kt index 080e1e6bd7c..c2518705ea6 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/KnownDescriptors.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/KnownDescriptors.kt @@ -138,7 +138,7 @@ open class KnownClassDescriptor( override fun isCompanionObject(): Boolean = false override fun isData(): Boolean = false override fun isInner(): Boolean = false - override fun isPlatform(): Boolean = false + override fun isHeader(): Boolean = false override fun isImpl(): Boolean = false override fun isExternal(): Boolean = false diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt index cab50bb2a1a..983f1b490cd 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt @@ -59,7 +59,7 @@ class JvmSharedVariablesManager(val builtIns: KotlinBuiltIns) : SharedVariablesM PropertyDescriptorImpl.create( refClass, Annotations.EMPTY, Modality.FINAL, Visibilities.PUBLIC, true, Name.identifier("element"), CallableMemberDescriptor.Kind.DECLARATION, SourceElement.NO_SOURCE, - /* lateInit = */ false, /* isConst = */ false, /* isPlatform = */ false, /* isImpl = */ false, + /* lateInit = */ false, /* isConst = */ false, /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ).initialize(type, dispatchReceiverParameter = refClass.thisAsReceiverParameter) } @@ -100,7 +100,7 @@ class JvmSharedVariablesManager(val builtIns: KotlinBuiltIns) : SharedVariablesM PropertyDescriptorImpl.create( genericRefClass, Annotations.EMPTY, Modality.FINAL, Visibilities.PUBLIC, true, Name.identifier("element"), CallableMemberDescriptor.Kind.DECLARATION, SourceElement.NO_SOURCE, - /* lateInit = */ false, /* isConst = */ false, /* isPlatform = */ false, /* isImpl = */ false, + /* lateInit = */ false, /* isConst = */ false, /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ).initialize( type = builtIns.anyType, diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SpecialDescriptorsFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SpecialDescriptorsFactory.kt index 8be81b5c1c9..d558c2e8559 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SpecialDescriptorsFactory.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SpecialDescriptorsFactory.kt @@ -129,7 +129,7 @@ class SpecialDescriptorsFactory( Annotations.EMPTY, Modality.FINAL, Visibilities.PUBLIC, false, Name.identifier("INSTANCE"), CallableMemberDescriptor.Kind.SYNTHESIZED, SourceElement.NO_SOURCE, /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, /* isImpl = */ false, /* isExternal = */ false + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ).initialize(objectDescriptor.defaultType) return instanceFieldDescriptor diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltinFunctionDescriptor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltinFunctionDescriptor.kt index 23954888006..c74735f5d60 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltinFunctionDescriptor.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltinFunctionDescriptor.kt @@ -54,7 +54,7 @@ abstract class IrBuiltinOperatorDescriptorBase(containingDeclaration: Declaratio override fun isOperator(): Boolean = false override fun isSuspend(): Boolean = false override fun isTailrec(): Boolean = false - override fun isPlatform(): Boolean = false + override fun isHeader(): Boolean = false override fun isImpl(): Boolean = false override fun hasStableParameterNames(): Boolean = true override fun hasSynthesizedParameterNames(): Boolean = false diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt index ac91c1f80b9..588dd471b6b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt @@ -60,7 +60,7 @@ abstract class IrDelegateDescriptorBase( SourceElement.NO_SOURCE, /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ) { diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt index 8d18a59bfcd..a6b4428e7b0 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt @@ -352,7 +352,7 @@ abstract class KtLightClassForSourceDeclaration(protected val classOrObject: KtC fun create(classOrObject: KtClassOrObject): KtLightClassForSourceDeclaration? { - if (classOrObject.getContainingKtFile().isScript || classOrObject.hasModifier(KtTokens.PLATFORM_KEYWORD)) { + if (classOrObject.getContainingKtFile().isScript || classOrObject.hasModifier(KtTokens.HEADER_KEYWORD)) { return null } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt index f59845424ac..ec366fc04ed 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt @@ -44,7 +44,7 @@ class FlatSignature private constructor( val hasExtensionReceiver: Boolean, val hasVarargs: Boolean, val numDefaults: Int, - val isPlatform: Boolean, + val isHeader: Boolean, val isSyntheticMember: Boolean ) { val isGeneric = typeParameters.isNotEmpty() @@ -65,7 +65,7 @@ class FlatSignature private constructor( hasExtensionReceiver = extensionReceiverType != null, hasVarargs = descriptor.valueParameters.any { it.varargElementType != null }, numDefaults = numDefaults, - isPlatform = descriptor is MemberDescriptor && descriptor.isPlatform, + isHeader = descriptor is MemberDescriptor && descriptor.isHeader, isSyntheticMember = descriptor is SyntheticMemberDescriptor<*> ) } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt index 20075a8eb8b..15954fdf6de 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt @@ -241,8 +241,8 @@ class OverloadingConflictResolver( if (isGeneric1 && isGeneric2) return false } - if (!call1.isPlatform && call2.isPlatform) return true - if (call1.isPlatform && !call2.isPlatform) return false + if (!call1.isHeader && call2.isHeader) return true + if (call1.isHeader && !call2.isHeader) return false return createEmptyConstraintSystem().isSignatureNotLessSpecific(call1, call2, SpecificityComparisonWithNumerics, specificityComparator) } diff --git a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt index f0531a86bb5..82025777ae0 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt @@ -2,28 +2,28 @@ // MODULE: m1-common // FILE: common.kt -platform typealias Foo = String +header typealias Foo = String -class Outer platform constructor() { - platform class Nested +class Outer header constructor() { + header class Nested - platform init {} + header init {} - platform fun foo() - platform val bar: Int + header fun foo() + header val bar: Int } fun foo() { - platform fun localFun() - platform var x = 42 - platform class Bar + header fun localFun() + header var x = 42 + header class Bar } // MODULE: m2-jvm // FILE: jvm.kt class Outer impl constructor() { - impl class Nested + impl class Nested impl init {} } @@ -31,5 +31,5 @@ class Outer impl constructor() { fun foo() { impl fun localFun() {} impl var x = 42 - impl class Bar + impl class Bar } diff --git a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt index 5222aa2f0eb..4e18ad2da3f 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt @@ -7,11 +7,11 @@ public final class Outer { public constructor Outer() public final val bar: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public final platform fun foo(): kotlin.Unit + public final header fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - public final platform class Nested { + public final header class Nested { public constructor Nested() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.kt index d4b37788ab4..8351801b0b9 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.kt @@ -2,15 +2,15 @@ // MODULE: m1-common // FILE: common.kt -platform interface Interface +header interface Interface -platform annotation class Anno(val prop: String) +header annotation class Anno(val prop: String) -platform object Object +header object Object -platform class Class +header class Class -platform enum class En { ENTRY } +header enum class En { ENTRY } // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.txt index 062a34a3f19..937f3d335aa 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/classKinds.txt @@ -1,7 +1,7 @@ // -- Module: -- package -public final platform annotation class Anno : kotlin.Annotation { +public final header annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ prop: kotlin.String) public final val prop: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -9,14 +9,14 @@ public final platform annotation class Anno : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class Class { +public final header class Class { public constructor Class() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform enum class En : kotlin.Enum { +public final header enum class En : kotlin.Enum { enum entry ENTRY private constructor En() @@ -33,13 +33,13 @@ public final platform enum class En : kotlin.Enum { public final /*synthesized*/ fun values(): kotlin.Array } -public platform interface Interface { +public header interface Interface { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public platform object Object { +public header object Object { private constructor Object() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.kt index 83028766590..a7f95e95ec9 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.kt @@ -1,14 +1,14 @@ // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform open class A { +header open class A { constructor(s: String) - constructor(n: Number) : this("A") + constructor(n: Number) : this("A") } -platform class B : A { +header class B : A { constructor(i: Int) - constructor() : super("B") + constructor() : super("B") } diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.txt index 6a71e5990d2..bba953a0e79 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/explicitConstructorDelegation.txt @@ -1,6 +1,6 @@ package -public open platform class A { +public open header class A { public constructor A(/*0*/ n: kotlin.Number) public constructor A(/*0*/ s: kotlin.String) public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -8,7 +8,7 @@ public open platform class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class B : A { +public final header class B : A { public constructor B() public constructor B(/*0*/ i: kotlin.Int) public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.kt index 6454c30f5b4..94e79a8e49e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.kt @@ -1,18 +1,18 @@ -// !DIAGNOSTICS: -PLATFORM_DEFINITION_WITHOUT_DECLARATION +// !DIAGNOSTICS: -IMPLEMENTATION_WITHOUT_HEADER // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform class C1 -platform class C2 -platform class C3 -platform class C4 -platform class C5 -platform class C6 -platform class C7 -platform class C8 -platform class C9 -platform class C10 +header class C1 +header class C2 +header class C3 +header class C4 +header class C5 +header class C6 +header class C7 +header class C8 +header class C9 +header class C10 // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.txt index 27b5a72d384..0f1ba0e2316 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/genericClassImplTypeAlias.txt @@ -1,70 +1,70 @@ // -- Module: -- package -public final platform class C1 { +public final header class C1 { public constructor C1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C10 { +public final header class C10 { public constructor C10() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C2 { +public final header class C2 { public constructor C2() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C3 { +public final header class C3 { public constructor C3() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C4 { +public final header class C4 { public constructor C4() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C5 { +public final header class C5 { public constructor C5() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C6 { +public final header class C6 { public constructor C6() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C7 { +public final header class C7 { public constructor C7() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C8 { +public final header class C8 { public constructor C8() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class C9 { +public final header class C9 { public constructor C9() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.kt index 1f8566b2101..2031d19f897 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.kt @@ -1,7 +1,7 @@ // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform class Foo { +header class Foo { val foo: String fun bar(x: Int): Int diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.txt index 7f610941740..5ad3b906cac 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassMember.txt @@ -1,10 +1,10 @@ // -- Module: -- package -public final platform class Foo { +public final header class Foo { public constructor Foo() public final val foo: kotlin.String - public final platform fun bar(/*0*/ x: kotlin.Int): kotlin.Int + public final header fun bar(/*0*/ x: kotlin.Int): kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.kt index 8401a252c31..d33a106589a 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.kt @@ -1,29 +1,29 @@ // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform class Foo( - val constructorProperty: String, +header class Foo( + val constructorProperty: String, constructorParameter: String ) { - init { + init { "no" } - constructor(s: String) { + constructor(s: String) { "no" } - constructor() : this("no") + constructor() : this("no") - val prop: String = "no" + val prop: String = "no" var getSet: String - get() = "no" - set(value) {} + get() = "no" + set(value) {} - fun defaultArg(value: String = "no") + fun defaultArg(value: String = "no") - fun functionWithBody(x: Int): Int { + fun functionWithBody(x: Int): Int { return x + 1 } } diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.txt index f3a370ca2b0..b55dea3ec1c 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/platformClassWithFunctionBody.txt @@ -1,15 +1,15 @@ package -public final platform class Foo { +public final header class Foo { public constructor Foo() public constructor Foo(/*0*/ s: kotlin.String) public constructor Foo(/*0*/ constructorProperty: kotlin.String, /*1*/ constructorParameter: kotlin.String) public final val constructorProperty: kotlin.String public final var getSet: kotlin.String public final val prop: kotlin.String = "no" - public final platform fun defaultArg(/*0*/ value: kotlin.String = ...): kotlin.Unit + public final header fun defaultArg(/*0*/ value: kotlin.String = ...): kotlin.Unit public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public final platform fun functionWithBody(/*0*/ x: kotlin.Int): kotlin.Int + public final header fun functionWithBody(/*0*/ x: kotlin.Int): kotlin.Int public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.kt index 053874029a5..b31851d3a78 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.kt @@ -1,7 +1,7 @@ // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform class Foo +header class Foo // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.txt index b5f304c8bbb..ff3aeb3c3d0 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/simplePlatformClass.txt @@ -1,7 +1,7 @@ // -- Module: -- package -public final platform class Foo { +public final header class Foo { public constructor Foo() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.kt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.kt index 3ef1e9e4a4c..9a249a2167d 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.kt @@ -6,7 +6,7 @@ interface I open class C interface J -platform class Foo : I, C, J +header class Foo : I, C, J // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.txt b/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.txt index fa5669b7261..e1b3ea03876 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/platformClass/superClass.txt @@ -8,7 +8,7 @@ public open class C { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final platform class Foo : I, C, J { +public final header class Foo : I, C, J { public constructor Foo() public open override /*3*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*3*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.kt index c70119b7208..4d66760f197 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.kt @@ -2,7 +2,7 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo(x: Int): Int +header fun foo(x: Int): Int fun callFromCommonCode(x: Int) = foo(x) diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.txt index 2270fe4fd6b..cd458e68a81 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callPlatformFun.txt @@ -2,7 +2,7 @@ package public fun callFromCommonCode(/*0*/ x: kotlin.Int): kotlin.Int -public platform fun foo(/*0*/ x: kotlin.Int): kotlin.Int +public header fun foo(/*0*/ x: kotlin.Int): kotlin.Int // -- Module: -- diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.kt index 6009179e011..a34b0aa6c40 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.kt @@ -2,7 +2,7 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo() -platform fun foo() +header fun foo() +header fun foo() -platform fun foo(x: Int) +header fun foo(x: Int) diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.txt index 10e92e8f7d6..ab106725681 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDeclarations.txt @@ -1,5 +1,5 @@ package -public platform fun foo(): kotlin.Unit -public platform fun foo(): kotlin.Unit -public platform fun foo(/*0*/ x: kotlin.Int): kotlin.Unit +public header fun foo(): kotlin.Unit +public header fun foo(): kotlin.Unit +public header fun foo(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.kt index 6cb49d3df9c..ccb01a86579 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.kt @@ -2,7 +2,7 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo() +header fun foo() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.txt index 2c17bb85349..a1d3524fc3f 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingPlatformDefinitions.txt @@ -1,7 +1,7 @@ // -- Module: -- package -public platform fun foo(): kotlin.Unit +public header fun foo(): kotlin.Unit // -- Module: -- diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.kt index 5994dc9e601..3c5f0b78500 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.kt @@ -3,16 +3,16 @@ // FILE: common.kt package common -platform fun foo() +header fun foo() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt package jvm -impl fun foo() {} +impl fun foo() {} // MODULE: m3-js(m1-common) // FILE: js.kt package js -impl fun foo() {} +impl fun foo() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.txt index c9d9abdf67f..2ad894bf4b5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationAndDefinitionInDIfferentPackages.txt @@ -2,7 +2,7 @@ package package common { - public platform fun foo(): kotlin.Unit + public header fun foo(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.kt index 74aef4fb1a7..e899a3c2bb3 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.kt @@ -2,4 +2,4 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo() +header fun foo() diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.txt index fd68685000d..d2f32ce3926 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/declarationWithoutDefinition.txt @@ -1,3 +1,3 @@ package -public platform fun foo(): kotlin.Unit +public header fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.kt index 0378f9d5ef1..5d55981ae20 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.kt @@ -2,4 +2,4 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo(x: Int, y: String = "") +header fun foo(x: Int, y: String = "") diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.txt index 24b83d32390..127ec370ec2 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.txt @@ -1,3 +1,3 @@ package -public platform fun foo(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String = ...): kotlin.Unit +public header fun foo(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String = ...): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/definitionWithoutDeclaration.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/definitionWithoutDeclaration.kt index 08c93317122..a7cb4f5e88c 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/definitionWithoutDeclaration.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/definitionWithoutDeclaration.kt @@ -2,4 +2,4 @@ // MODULE: m1-jvm // FILE: jvm.kt -impl fun foo() { } +impl fun foo() { } diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt index 03d50bc88c1..75ba5595b4c 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt @@ -2,17 +2,17 @@ // MODULE: m1-common // FILE: common.kt -inline platform fun inlineFun() -platform fun nonInlineFun() +inline header fun inlineFun() +header fun nonInlineFun() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt -impl fun inlineFun() { } +impl fun inlineFun() { } impl fun nonInlineFun() { } // MODULE: m3-js(m1-common) // FILE: js.kt impl inline fun inlineFun() { } -impl inline fun nonInlineFun() { } +impl inline fun nonInlineFun() { } diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt index 9869d58c471..b0d4b9c2171 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt @@ -1,8 +1,8 @@ // -- Module: -- package -public inline platform fun inlineFun(): kotlin.Unit -public platform fun nonInlineFun(): kotlin.Unit +public inline header fun inlineFun(): kotlin.Unit +public header fun nonInlineFun(): kotlin.Unit // -- Module: -- diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.kt index 5642d64c1b5..686a0788bf0 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.kt @@ -2,8 +2,8 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo() +header fun foo() -platform fun foo() {} +header fun foo() {} -platform fun bar() {} +header fun bar() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.txt index 4b2d2d96cd0..cc59f9821de 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDeclarationWithBody.txt @@ -1,5 +1,5 @@ package -public platform fun bar(): kotlin.Unit -public platform fun foo(): kotlin.Unit -public platform fun foo(): kotlin.Unit +public header fun bar(): kotlin.Unit +public header fun foo(): kotlin.Unit +public header fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.kt index b3b694e2907..9559a216007 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.kt @@ -2,11 +2,11 @@ // MODULE: m1-common // FILE: common.kt -platform fun foo() +header fun foo() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt impl fun foo() -impl fun bar() +impl fun bar() diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.txt index 7343d4c5ba1..b1dacf691c1 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/platformDefinitionWithoutBody.txt @@ -1,7 +1,7 @@ // -- Module: -- package -public platform fun foo(): kotlin.Unit +public header fun foo(): kotlin.Unit // -- Module: -- diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.kt index 8d8bc53110d..f29a4d0d38b 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.kt @@ -1,7 +1,7 @@ // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform fun foo() +header fun foo() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.txt index bb3d7a94b32..52be88a0c10 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simplePlatformFun.txt @@ -1,7 +1,7 @@ // -- Module: -- package -public platform fun foo(): kotlin.Unit +public header fun foo(): kotlin.Unit // -- Module: -- diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt index f77e0857c70..af29c49d2f1 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt @@ -2,39 +2,39 @@ // MODULE: m1-common // FILE: common.kt -platform val justVal: String -platform var justVar: String +header val justVal: String +header var justVar: String -platform val String.extensionVal: Unit -platform var T.genericExtensionVar: T +header val String.extensionVal: Unit +header var T.genericExtensionVar: T -platform val valWithGet: String +header val valWithGet: String get -platform var varWithGetSet: String +header var varWithGetSet: String get set -platform var varWithPlatformGetSet: String - platform get - platform set +header var varWithPlatformGetSet: String + header get + header set -platform val backingFieldVal: String = "no" -platform var backingFieldVar: String = "no" +header val backingFieldVal: String = "no" +header var backingFieldVar: String = "no" -platform val customAccessorVal: String - get() = "no" -platform var customAccessorVar: String - get() = "no" - set(value) {} +header val customAccessorVal: String + get() = "no" +header var customAccessorVar: String + get() = "no" + set(value) {} -platform const val constVal: Int +header const val constVal: Int -platform lateinit var lateinitVar: String +header lateinit var lateinitVar: String -platform val delegated: String by Delegate +header val delegated: String by Delegate object Delegate { operator fun getValue(x: Any?, y: Any?): String = "" } fun test(): String { - platform val localVariable: String + header val localVariable: String localVariable = "no" return localVariable } diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simplePlatformVar.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simplePlatformVar.kt index 4200bc90c8a..5c7c627f335 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simplePlatformVar.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simplePlatformVar.kt @@ -1,7 +1,7 @@ // !LANGUAGE: +MultiPlatformProjects // MODULE: m1-common // FILE: common.kt -platform var foo: String +header var foo: String // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt b/compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt index a488b916797..64a5b8f3c76 100644 --- a/compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt +++ b/compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt @@ -1,6 +1,6 @@ -platform fun foo1() -platform val bar1 = 42 -platform class Baz1 +header fun foo1() +header val bar1 = 42 +header class Baz1 impl fun foo2() = 42 impl val bar2: Int diff --git a/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt b/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt index 0ff7d1151e4..db391be7cc0 100644 --- a/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt +++ b/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt @@ -1,3 +1,3 @@ -platform class Foo { +header class Foo { constructor(s: String) } diff --git a/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt b/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt index a4ad3c3a915..624976f2d09 100644 --- a/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt +++ b/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt @@ -5,7 +5,7 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt:1:16: error: no definition is found for platform declaration 'Foo' +compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt:1:14: error: no implementation is found for header declaration 'Foo' The following declaration is incompatible because some members are not implemented. No implementations are found for members listed below: @@ -14,8 +14,8 @@ No implementations are found for members listed below: The following declaration is incompatible because parameter types are different: public constructor Foo(s: Array) -platform class Foo { - ^ +header class Foo { + ^ compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl class Foo { ^ diff --git a/compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt b/compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt index 03bf3dfa9fe..c2550dd6a42 100644 --- a/compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt +++ b/compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt @@ -1,7 +1,7 @@ -platform open class Base { +header open class Base { fun base() } -platform class Derived : Base { +header class Derived : Base { fun derived() } diff --git a/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt b/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt index 383c122682b..a9481f243b0 100644 --- a/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt +++ b/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt @@ -1,3 +1,3 @@ -platform class Foo { +header class Foo { fun function(b: ByteArray): Int } diff --git a/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt b/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt index 2d731e465b7..1e87769a26f 100644 --- a/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt +++ b/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt @@ -5,17 +5,17 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt:1:16: error: no definition is found for platform declaration 'Foo' +compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt:1:14: error: no implementation is found for header declaration 'Foo' The following declaration is incompatible because some members are not implemented. No implementations are found for members listed below: - public final platform fun function(b: ByteArray): Int + public final header fun function(b: ByteArray): Int The following declaration is incompatible because return type is different: public final impl fun function(b: ByteArray): Long -platform class Foo { - ^ +header class Foo { + ^ compiler/testData/multiplatform/classScopes/functionIncorrectSignature/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl class Foo { ^ diff --git a/compiler/testData/multiplatform/classScopes/missingConstructor/common.kt b/compiler/testData/multiplatform/classScopes/missingConstructor/common.kt index 0ff7d1151e4..db391be7cc0 100644 --- a/compiler/testData/multiplatform/classScopes/missingConstructor/common.kt +++ b/compiler/testData/multiplatform/classScopes/missingConstructor/common.kt @@ -1,3 +1,3 @@ -platform class Foo { +header class Foo { constructor(s: String) } diff --git a/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt b/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt index 4f92c0eeb8b..8a5a60cc747 100644 --- a/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt +++ b/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt @@ -5,7 +5,7 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/classScopes/missingConstructor/common.kt:1:16: error: no definition is found for platform declaration 'Foo' +compiler/testData/multiplatform/classScopes/missingConstructor/common.kt:1:14: error: no implementation is found for header declaration 'Foo' The following declaration is incompatible because some members are not implemented. No implementations are found for members listed below: @@ -14,8 +14,8 @@ No implementations are found for members listed below: The following declaration is incompatible because number of value parameters is different: public constructor Foo() -platform class Foo { - ^ +header class Foo { + ^ compiler/testData/multiplatform/classScopes/missingConstructor/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl class Foo ^ diff --git a/compiler/testData/multiplatform/classScopes/missingFunction/common.kt b/compiler/testData/multiplatform/classScopes/missingFunction/common.kt index f2d8816ecd2..a2c77b484e8 100644 --- a/compiler/testData/multiplatform/classScopes/missingFunction/common.kt +++ b/compiler/testData/multiplatform/classScopes/missingFunction/common.kt @@ -1,3 +1,3 @@ -platform class Foo { +header class Foo { fun function(s: String) } diff --git a/compiler/testData/multiplatform/classScopes/missingFunction/output.txt b/compiler/testData/multiplatform/classScopes/missingFunction/output.txt index 62c0680d85f..f17211000ed 100644 --- a/compiler/testData/multiplatform/classScopes/missingFunction/output.txt +++ b/compiler/testData/multiplatform/classScopes/missingFunction/output.txt @@ -5,14 +5,14 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/classScopes/missingFunction/common.kt:1:16: error: no definition is found for platform declaration 'Foo' +compiler/testData/multiplatform/classScopes/missingFunction/common.kt:1:14: error: no implementation is found for header declaration 'Foo' The following declaration is incompatible because some members are not implemented. No implementations are found for members listed below: - public final platform fun function(s: String): Unit + public final header fun function(s: String): Unit -platform class Foo { - ^ +header class Foo { + ^ compiler/testData/multiplatform/classScopes/missingFunction/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl class Foo ^ diff --git a/compiler/testData/multiplatform/classScopes/simple/common.kt b/compiler/testData/multiplatform/classScopes/simple/common.kt index ff5d0be3e5d..1ca6125ced6 100644 --- a/compiler/testData/multiplatform/classScopes/simple/common.kt +++ b/compiler/testData/multiplatform/classScopes/simple/common.kt @@ -1,4 +1,4 @@ -platform class Foo(param: String) { +header class Foo(param: String) { var property: Int fun function(p: List): T diff --git a/compiler/testData/multiplatform/genericDeclarations/common.kt b/compiler/testData/multiplatform/genericDeclarations/common.kt index 9cff5eb1326..82decb00331 100644 --- a/compiler/testData/multiplatform/genericDeclarations/common.kt +++ b/compiler/testData/multiplatform/genericDeclarations/common.kt @@ -1,13 +1,13 @@ -platform fun f1(): T +header fun f1(): T -platform fun f2(t: T) +header fun f2(t: T) -platform fun , V : MutableList> f3(v: Map>, w: Comparable<*>) +header fun , V : MutableList> f3(v: Map>, w: Comparable<*>) -platform fun > Array.sort(): Unit +header fun > Array.sort(): Unit -platform class C1 -platform class C2> -platform class C3> +header class C1 +header class C2> +header class C3> -platform abstract class AbstractList : MutableList +header abstract class AbstractList : MutableList diff --git a/compiler/testData/multiplatform/implementClassWithTypeAlias/common.kt b/compiler/testData/multiplatform/implementClassWithTypeAlias/common.kt index fc53898517d..7586d114f7e 100644 --- a/compiler/testData/multiplatform/implementClassWithTypeAlias/common.kt +++ b/compiler/testData/multiplatform/implementClassWithTypeAlias/common.kt @@ -1,3 +1,3 @@ -platform class C1 { +header class C1 { fun foo(a: A): List? } diff --git a/compiler/testData/multiplatform/incompatibleCallables/common.kt b/compiler/testData/multiplatform/incompatibleCallables/common.kt index 442585e840a..3f21ad7cb2f 100644 --- a/compiler/testData/multiplatform/incompatibleCallables/common.kt +++ b/compiler/testData/multiplatform/incompatibleCallables/common.kt @@ -1,36 +1,36 @@ -platform fun f1() +header fun f1() -platform fun f2(name: String) +header fun f2(name: String) -platform fun f3(name: String) -platform fun String.f3ext() +header fun f3(name: String) +header fun String.f3ext() -platform fun f4(name: String) +header fun f4(name: String) -platform fun String.f5() +header fun String.f5() -platform fun f6(p1: String, p2: Int) +header fun f6(p1: String, p2: Int) -platform fun f7() +header fun f7() -internal platform fun f8() -private platform fun f9() -public platform fun f10() +internal header fun f8() +private header fun f9() +public header fun f10() -platform fun f11() -platform fun > f12() -platform fun > f13() +header fun f11() +header fun > f12() +header fun > f13() -platform inline fun f14() -platform inline fun f15() +header inline fun f14() +header inline fun f15() -platform fun f16(s: String) +header fun f16(s: String) -platform fun f17(vararg s: String) -platform fun f18(s: Array) -platform inline fun f19(crossinline s: () -> Unit) -platform inline fun f20(s: () -> Unit) -platform inline fun f21(noinline s: () -> Unit) -platform inline fun f22(s: () -> Unit) -platform fun f23(coroutine c: Unit.() -> Continuation) -platform fun f24(c: Unit.() -> Continuation) +header fun f17(vararg s: String) +header fun f18(s: Array) +header inline fun f19(crossinline s: () -> Unit) +header inline fun f20(s: () -> Unit) +header inline fun f21(noinline s: () -> Unit) +header inline fun f22(s: () -> Unit) +header fun f23(coroutine c: Unit.() -> Continuation) +header fun f24(c: Unit.() -> Continuation) diff --git a/compiler/testData/multiplatform/incompatibleCallables/output.txt b/compiler/testData/multiplatform/incompatibleCallables/output.txt index d335a28cd2b..cc90f767bf4 100644 --- a/compiler/testData/multiplatform/incompatibleCallables/output.txt +++ b/compiler/testData/multiplatform/incompatibleCallables/output.txt @@ -5,137 +5,137 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/incompatibleCallables/common.kt:1:1: error: no definition is found for platform declaration 'f1' +compiler/testData/multiplatform/incompatibleCallables/common.kt:1:1: error: no implementation is found for header declaration 'f1' The following declaration is incompatible because return type is different: public impl fun f1(): String -platform fun f1() +header fun f1() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:3:1: error: no definition is found for platform declaration 'f2' +compiler/testData/multiplatform/incompatibleCallables/common.kt:3:1: error: no implementation is found for header declaration 'f2' The following declaration is incompatible because parameter names are different: public impl fun f2(otherName: String): Unit -platform fun f2(name: String) +header fun f2(name: String) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:5:1: error: no definition is found for platform declaration 'f3' +compiler/testData/multiplatform/incompatibleCallables/common.kt:5:1: error: no implementation is found for header declaration 'f3' The following declaration is incompatible because parameter types are different: public impl fun f3(name: Double): Unit -platform fun f3(name: String) +header fun f3(name: String) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:6:1: error: no definition is found for platform declaration 'f3ext' +compiler/testData/multiplatform/incompatibleCallables/common.kt:6:1: error: no implementation is found for header declaration 'f3ext' The following declaration is incompatible because parameter types are different: public impl fun Double.f3ext(): Unit -platform fun String.f3ext() +header fun String.f3ext() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:8:1: error: no definition is found for platform declaration 'f4' +compiler/testData/multiplatform/incompatibleCallables/common.kt:8:1: error: no implementation is found for header declaration 'f4' The following declaration is incompatible because parameter shapes are different (extension vs non-extension): public impl fun String.f4(): Unit -platform fun f4(name: String) +header fun f4(name: String) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:10:1: error: no definition is found for platform declaration 'f5' +compiler/testData/multiplatform/incompatibleCallables/common.kt:10:1: error: no implementation is found for header declaration 'f5' The following declaration is incompatible because parameter shapes are different (extension vs non-extension): public impl fun f5(name: String): Unit -platform fun String.f5() +header fun String.f5() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:12:1: error: no definition is found for platform declaration 'f6' +compiler/testData/multiplatform/incompatibleCallables/common.kt:12:1: error: no implementation is found for header declaration 'f6' The following declaration is incompatible because number of value parameters is different: public impl fun f6(p2: Int): Unit -platform fun f6(p1: String, p2: Int) +header fun f6(p1: String, p2: Int) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:14:1: error: no definition is found for platform declaration 'f7' +compiler/testData/multiplatform/incompatibleCallables/common.kt:14:1: error: no implementation is found for header declaration 'f7' The following declaration is incompatible because number of type parameters is different: public impl fun f7(): Unit -platform fun f7() +header fun f7() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:16:1: error: no definition is found for platform declaration 'f8' +compiler/testData/multiplatform/incompatibleCallables/common.kt:16:1: error: no implementation is found for header declaration 'f8' The following declaration is incompatible because visibility is different: public impl fun f8(): Unit -internal platform fun f8() +internal header fun f8() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:17:1: error: no definition is found for platform declaration 'f9' +compiler/testData/multiplatform/incompatibleCallables/common.kt:17:1: error: no implementation is found for header declaration 'f9' The following declaration is incompatible because visibility is different: internal impl fun f9(): Unit -private platform fun f9() +private header fun f9() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:18:1: error: no definition is found for platform declaration 'f10' +compiler/testData/multiplatform/incompatibleCallables/common.kt:18:1: error: no implementation is found for header declaration 'f10' The following declaration is incompatible because visibility is different: private impl fun f10(): Unit -public platform fun f10() +public header fun f10() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:24:1: error: no definition is found for platform declaration 'f14' +compiler/testData/multiplatform/incompatibleCallables/common.kt:24:1: error: no implementation is found for header declaration 'f14' The following declaration is incompatible because some type parameter is reified in one declaration and non-reified in the other: public inline impl fun f14(): Unit -platform inline fun f14() +header inline fun f14() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:25:1: error: no definition is found for platform declaration 'f15' +compiler/testData/multiplatform/incompatibleCallables/common.kt:25:1: error: no implementation is found for header declaration 'f15' The following declaration is incompatible because some type parameter is reified in one declaration and non-reified in the other: public inline impl fun f15(): Unit -platform inline fun f15() +header inline fun f15() ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:27:1: error: no definition is found for platform declaration 'f16' +compiler/testData/multiplatform/incompatibleCallables/common.kt:27:1: error: no implementation is found for header declaration 'f16' The following declaration is incompatible because some parameters have default values: public impl fun f16(s: String = ...): Unit -platform fun f16(s: String) +header fun f16(s: String) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:29:1: error: no definition is found for platform declaration 'f17' +compiler/testData/multiplatform/incompatibleCallables/common.kt:29:1: error: no implementation is found for header declaration 'f17' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public impl fun f17(s: Array): Unit -platform fun f17(vararg s: String) +header fun f17(vararg s: String) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:30:1: error: no definition is found for platform declaration 'f18' +compiler/testData/multiplatform/incompatibleCallables/common.kt:30:1: error: no implementation is found for header declaration 'f18' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public impl fun f18(vararg s: String): Unit -platform fun f18(s: Array) +header fun f18(s: Array) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:31:1: error: no definition is found for platform declaration 'f19' +compiler/testData/multiplatform/incompatibleCallables/common.kt:31:1: error: no implementation is found for header declaration 'f19' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public inline impl fun f19(s: () -> Unit): Unit -platform inline fun f19(crossinline s: () -> Unit) +header inline fun f19(crossinline s: () -> Unit) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:32:1: error: no definition is found for platform declaration 'f20' +compiler/testData/multiplatform/incompatibleCallables/common.kt:32:1: error: no implementation is found for header declaration 'f20' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public inline impl fun f20(crossinline s: () -> Unit): Unit -platform inline fun f20(s: () -> Unit) +header inline fun f20(s: () -> Unit) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:33:1: error: no definition is found for platform declaration 'f21' +compiler/testData/multiplatform/incompatibleCallables/common.kt:33:1: error: no implementation is found for header declaration 'f21' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public inline impl fun f21(s: () -> Unit): Unit -platform inline fun f21(noinline s: () -> Unit) +header inline fun f21(noinline s: () -> Unit) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:34:1: error: no definition is found for platform declaration 'f22' +compiler/testData/multiplatform/incompatibleCallables/common.kt:34:1: error: no implementation is found for header declaration 'f22' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public inline impl fun f22(noinline s: () -> Unit): Unit -platform inline fun f22(s: () -> Unit) +header inline fun f22(s: () -> Unit) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:35:1: error: no definition is found for platform declaration 'f23' +compiler/testData/multiplatform/incompatibleCallables/common.kt:35:1: error: no implementation is found for header declaration 'f23' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public impl fun f23(c: Unit.() -> Continuation): Unit -platform fun f23(coroutine c: Unit.() -> Continuation) +header fun f23(coroutine c: Unit.() -> Continuation) ^ -compiler/testData/multiplatform/incompatibleCallables/common.kt:36:1: error: no definition is found for platform declaration 'f24' +compiler/testData/multiplatform/incompatibleCallables/common.kt:36:1: error: no implementation is found for header declaration 'f24' The following declaration is incompatible because parameter modifiers are different (vararg, coroutine, crossinline, noinline): public impl fun f24(coroutine c: Unit.() -> Continuation): Unit -platform fun f24(c: Unit.() -> Continuation) +header fun f24(c: Unit.() -> Continuation) ^ compiler/testData/multiplatform/incompatibleCallables/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl fun f1(): String = "" diff --git a/compiler/testData/multiplatform/incompatibleClasses/common.kt b/compiler/testData/multiplatform/incompatibleClasses/common.kt index 8bf528b935c..5e33fa0c7b4 100644 --- a/compiler/testData/multiplatform/incompatibleClasses/common.kt +++ b/compiler/testData/multiplatform/incompatibleClasses/common.kt @@ -1,25 +1,25 @@ -platform class PClass -platform interface PInterface -platform object PObject -platform enum class PEnumClass -platform annotation class PAnnotationClass +header class PClass +header interface PInterface +header object PObject +header enum class PEnumClass +header annotation class PAnnotationClass -internal platform object InternalObject -public platform object PublicObject -private platform object PrivateObject +internal header object InternalObject +public header object PublicObject +private header object PrivateObject -open platform class OpenClass -abstract platform class AbstractClass -final platform class FinalClass +open header class OpenClass +abstract header class AbstractClass +final header class FinalClass -// platform data class DataClass(val x: Int) -platform class NonDataClass(x: Int) +// header data class DataClass(val x: Int) +header class NonDataClass(x: Int) -platform class C1 -platform class C2 -platform class C3 +header class C1 +header class C2 +header class C3 -platform class C4 +header class C4 -platform abstract class ExtendsNumber : Number +header abstract class ExtendsNumber : Number diff --git a/compiler/testData/multiplatform/incompatibleClasses/output.txt b/compiler/testData/multiplatform/incompatibleClasses/output.txt index 75ae5d7486c..6b2e77fbff6 100644 --- a/compiler/testData/multiplatform/incompatibleClasses/output.txt +++ b/compiler/testData/multiplatform/incompatibleClasses/output.txt @@ -5,96 +5,96 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/incompatibleClasses/common.kt:1:16: error: no definition is found for platform declaration 'PClass' +compiler/testData/multiplatform/incompatibleClasses/common.kt:1:14: error: no implementation is found for header declaration 'PClass' The following declaration is incompatible because class kinds are different (class, interface, object, enum, annotation): public impl interface PClass -platform class PClass - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:2:20: error: no definition is found for platform declaration 'PInterface' +header class PClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:2:18: error: no implementation is found for header declaration 'PInterface' The following declaration is incompatible because class kinds are different (class, interface, object, enum, annotation): public impl object PInterface -platform interface PInterface - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:3:10: error: no definition is found for platform declaration 'PObject' +header interface PInterface + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:3:8: error: no implementation is found for header declaration 'PObject' The following declaration is incompatible because class kinds are different (class, interface, object, enum, annotation): public final impl enum class PObject : Enum -platform object PObject - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:4:21: error: no definition is found for platform declaration 'PEnumClass' +header object PObject + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:4:19: error: no implementation is found for header declaration 'PEnumClass' The following declaration is incompatible because class kinds are different (class, interface, object, enum, annotation): public final impl annotation class PEnumClass : Annotation -platform enum class PEnumClass - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:5:27: error: no definition is found for platform declaration 'PAnnotationClass' +header enum class PEnumClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:5:25: error: no implementation is found for header declaration 'PAnnotationClass' The following declaration is incompatible because class kinds are different (class, interface, object, enum, annotation): public final impl class PAnnotationClass -platform annotation class PAnnotationClass - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:7:19: error: no definition is found for platform declaration 'InternalObject' +header annotation class PAnnotationClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:7:17: error: no implementation is found for header declaration 'InternalObject' The following declaration is incompatible because visibility is different: private impl object InternalObject -internal platform object InternalObject - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:8:17: error: no definition is found for platform declaration 'PublicObject' +internal header object InternalObject + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:8:15: error: no implementation is found for header declaration 'PublicObject' The following declaration is incompatible because visibility is different: internal impl object PublicObject -public platform object PublicObject - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:9:18: error: no definition is found for platform declaration 'PrivateObject' +public header object PublicObject + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:9:16: error: no implementation is found for header declaration 'PrivateObject' The following declaration is incompatible because visibility is different: public impl object PrivateObject -private platform object PrivateObject - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:11:21: error: no definition is found for platform declaration 'OpenClass' +private header object PrivateObject + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:11:19: error: no implementation is found for header declaration 'OpenClass' The following declaration is incompatible because modality is different: public final impl class OpenClass -open platform class OpenClass - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:12:25: error: no definition is found for platform declaration 'AbstractClass' +open header class OpenClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:12:23: error: no implementation is found for header declaration 'AbstractClass' The following declaration is incompatible because modality is different: public open impl class AbstractClass -abstract platform class AbstractClass - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:13:22: error: no definition is found for platform declaration 'FinalClass' +abstract header class AbstractClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:13:20: error: no implementation is found for header declaration 'FinalClass' The following declaration is incompatible because modality is different: public abstract impl class FinalClass -final platform class FinalClass - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:16:16: error: no definition is found for platform declaration 'NonDataClass' +final header class FinalClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:16:14: error: no implementation is found for header declaration 'NonDataClass' The following declaration is incompatible because modifiers are different (data): public final impl data class NonDataClass -platform class NonDataClass(x: Int) - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:18:16: error: no definition is found for platform declaration 'C1' +header class NonDataClass(x: Int) + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:18:14: error: no implementation is found for header declaration 'C1' The following declaration is incompatible because number of type parameters is different: public final impl class C1 -platform class C1 - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:19:16: error: no definition is found for platform declaration 'C2' +header class C1 + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:19:14: error: no implementation is found for header declaration 'C2' The following declaration is incompatible because declaration-site variances of type parameters are different: public final impl class C2 -platform class C2 - ^ -compiler/testData/multiplatform/incompatibleClasses/common.kt:25:25: error: no definition is found for platform declaration 'ExtendsNumber' +header class C2 + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:25:23: error: no implementation is found for header declaration 'ExtendsNumber' The following declaration is incompatible because some supertypes are missing in the implementation: public abstract impl class ExtendsNumber -platform abstract class ExtendsNumber : Number - ^ +header abstract class ExtendsNumber : Number + ^ compiler/testData/multiplatform/incompatibleClasses/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl interface PClass ^ diff --git a/compiler/testData/multiplatform/incompatibleFunctions/common.kt b/compiler/testData/multiplatform/incompatibleFunctions/common.kt index 22f5fa1c0ae..033190851c9 100644 --- a/compiler/testData/multiplatform/incompatibleFunctions/common.kt +++ b/compiler/testData/multiplatform/incompatibleFunctions/common.kt @@ -1,14 +1,14 @@ -platform infix fun Int.plus(s: CharSequence): Int -platform fun Int.minus(s: String): Int +header infix fun Int.plus(s: CharSequence): Int +header fun Int.minus(s: String): Int -platform operator fun Double.times(x: CharArray) -platform fun Double.divide(x: ByteArray) +header operator fun Double.times(x: CharArray) +header fun Double.divide(x: ByteArray) -platform external fun f1() -platform fun g1() +header external fun f1() +header fun g1() -platform inline fun f2() -platform fun g2() +header inline fun f2() +header fun g2() -platform tailrec fun f3() -platform fun g3() +header tailrec fun f3() +header fun g3() diff --git a/compiler/testData/multiplatform/incompatibleFunctions/output.txt b/compiler/testData/multiplatform/incompatibleFunctions/output.txt index c770dc78f0b..69ca0e9ce07 100644 --- a/compiler/testData/multiplatform/incompatibleFunctions/output.txt +++ b/compiler/testData/multiplatform/incompatibleFunctions/output.txt @@ -5,65 +5,65 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/incompatibleFunctions/common.kt:1:1: error: no definition is found for platform declaration 'plus' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:1:1: error: no implementation is found for header declaration 'plus' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public impl fun Int.plus(s: CharSequence): Int -platform infix fun Int.plus(s: CharSequence): Int +header infix fun Int.plus(s: CharSequence): Int ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:2:1: error: no definition is found for platform declaration 'minus' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:2:1: error: no implementation is found for header declaration 'minus' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public infix impl fun Int.minus(s: String): Int -platform fun Int.minus(s: String): Int +header fun Int.minus(s: String): Int ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:4:1: error: no definition is found for platform declaration 'times' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:4:1: error: no implementation is found for header declaration 'times' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public impl fun Double.times(x: CharArray): Unit -platform operator fun Double.times(x: CharArray) +header operator fun Double.times(x: CharArray) ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:5:1: error: no definition is found for platform declaration 'divide' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:5:1: error: no implementation is found for header declaration 'divide' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public operator impl fun Double.divide(x: ByteArray): Unit -platform fun Double.divide(x: ByteArray) +header fun Double.divide(x: ByteArray) ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:7:1: error: no definition is found for platform declaration 'f1' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:7:1: error: no implementation is found for header declaration 'f1' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public impl fun f1(): Unit -platform external fun f1() +header external fun f1() ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:8:1: error: no definition is found for platform declaration 'g1' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:8:1: error: no implementation is found for header declaration 'g1' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public external impl fun g1(): Unit -platform fun g1() +header fun g1() ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:10:1: error: no definition is found for platform declaration 'f2' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:10:1: error: no implementation is found for header declaration 'f2' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public impl fun f2(): Unit -platform inline fun f2() +header inline fun f2() ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:11:1: error: no definition is found for platform declaration 'g2' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:11:1: error: no implementation is found for header declaration 'g2' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public inline impl fun g2(): Unit -platform fun g2() +header fun g2() ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:13:1: error: no definition is found for platform declaration 'f3' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:13:1: error: no implementation is found for header declaration 'f3' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public impl fun f3(): Unit -platform tailrec fun f3() +header tailrec fun f3() ^ -compiler/testData/multiplatform/incompatibleFunctions/common.kt:14:1: error: no definition is found for platform declaration 'g3' +compiler/testData/multiplatform/incompatibleFunctions/common.kt:14:1: error: no implementation is found for header declaration 'g3' The following declaration is incompatible because modifiers are different (external, infix, inline, operator, suspend, tailrec): public tailrec impl fun g3(): Unit -platform fun g3() +header fun g3() ^ compiler/testData/multiplatform/incompatibleFunctions/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl fun Int.plus(s: CharSequence): Int = 0 diff --git a/compiler/testData/multiplatform/incompatibleProperties/common.kt b/compiler/testData/multiplatform/incompatibleProperties/common.kt index 8f4eade6f63..0a3059997bb 100644 --- a/compiler/testData/multiplatform/incompatibleProperties/common.kt +++ b/compiler/testData/multiplatform/incompatibleProperties/common.kt @@ -1,2 +1,2 @@ -platform val pval: String -platform var pvar: String +header val pval: String +header var pvar: String diff --git a/compiler/testData/multiplatform/incompatibleProperties/output.txt b/compiler/testData/multiplatform/incompatibleProperties/output.txt index 97a2ae8a542..6a03cb79d2b 100644 --- a/compiler/testData/multiplatform/incompatibleProperties/output.txt +++ b/compiler/testData/multiplatform/incompatibleProperties/output.txt @@ -5,17 +5,17 @@ Output: -- JVM -- Exit code: COMPILATION_ERROR Output: -compiler/testData/multiplatform/incompatibleProperties/common.kt:1:1: error: no definition is found for platform declaration 'pval' +compiler/testData/multiplatform/incompatibleProperties/common.kt:1:1: error: no implementation is found for header declaration 'pval' The following declaration is incompatible because property kinds are different (val vs var): public var pval: String -platform val pval: String +header val pval: String ^ -compiler/testData/multiplatform/incompatibleProperties/common.kt:2:1: error: no definition is found for platform declaration 'pvar' +compiler/testData/multiplatform/incompatibleProperties/common.kt:2:1: error: no implementation is found for header declaration 'pvar' The following declaration is incompatible because property kinds are different (val vs var): public val pvar: String -platform var pvar: String +header var pvar: String ^ compiler/testData/multiplatform/incompatibleProperties/jvm.kt:1:1: error: modifier 'impl' is only applicable to members that are initially declared in platform-independent code impl var pval: String = "" diff --git a/compiler/testData/multiplatform/incorrectImplInClass/common.kt b/compiler/testData/multiplatform/incorrectImplInClass/common.kt index 84d5a6e54da..b7b0f1b26c6 100644 --- a/compiler/testData/multiplatform/incorrectImplInClass/common.kt +++ b/compiler/testData/multiplatform/incorrectImplInClass/common.kt @@ -1 +1 @@ -platform class Foo +header class Foo diff --git a/compiler/testData/multiplatform/simple/common.kt b/compiler/testData/multiplatform/simple/common.kt index b79d7564b05..e0e045dc4dc 100644 --- a/compiler/testData/multiplatform/simple/common.kt +++ b/compiler/testData/multiplatform/simple/common.kt @@ -1,4 +1,4 @@ -platform class Printer { +header class Printer { fun print(message: String) } diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.java b/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.java index ab6b45abb58..4bc0155eb16 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.java @@ -417,7 +417,7 @@ public abstract class AbstractDiagnosticsTest extends BaseDiagnosticsTest { List dependencies = moduleDescriptor.getTestOnly_AllDependentModules(); // TODO: diagnostics on common code reported during the platform module analysis should be distinguished somehow - // E.g. "... + // E.g. "... List result = new ArrayList(0); for (ModuleDescriptorImpl dependency : dependencies) { if (dependency.getCapability(MultiTargetPlatform.CAPABILITY) == MultiTargetPlatform.Common.INSTANCE) { diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java b/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java index d63554538bc..c0cc6819764 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java +++ b/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java @@ -205,8 +205,8 @@ public class RecursiveDescriptorComparator { } } - // 'platform' declarations do not belong to the platform-specific module, even though they participate in the analysis - if (descriptor instanceof MemberDescriptor && ((MemberDescriptor) descriptor).isPlatform() && + // 'header' declarations do not belong to the platform-specific module, even though they participate in the analysis + if (descriptor instanceof MemberDescriptor && ((MemberDescriptor) descriptor).isHeader() && module.getCapability(MultiTargetPlatform.CAPABILITY) != MultiTargetPlatform.Common.INSTANCE) return false; return module.equals(DescriptorUtils.getContainingModule(descriptor)); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java index 992bf22d0e5..959c58b2842 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java @@ -46,7 +46,7 @@ public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements Ja boolean isStaticFinal ) { super(containingDeclaration, original, annotations, modality, visibility, isVar, name, kind, source, - /* lateInit = */ false, /* isConst = */ false, /* isPlatform = */ false, /* isImpl = */ false, /* isExternal = */ false); + /* lateInit = */ false, /* isConst = */ false, /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false); this.isStaticFinal = isStaticFinal; } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt index 4abd1d29fa4..3a90d58c7cd 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -100,7 +100,7 @@ class LazyJavaClassDescriptor( override fun isInner() = isInner override fun isData() = false override fun isCompanionObject() = false - override fun isPlatform() = false + override fun isHeader() = false override fun isImpl() = false private val typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt index 3ee8f248fe6..ea8b4079cfa 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt @@ -102,7 +102,7 @@ class FunctionClassDescriptor( override fun isCompanionObject() = false override fun isInner() = false override fun isData() = false - override fun isPlatform() = false + override fun isHeader() = false override fun isImpl() = false override fun isExternal() = false override val annotations: Annotations get() = Annotations.EMPTY diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/MemberDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/MemberDescriptor.java index ddc7d061336..dde19d00f72 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/MemberDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/MemberDescriptor.java @@ -26,7 +26,7 @@ public interface MemberDescriptor extends DeclarationDescriptorNonRoot, Declarat @NotNull Visibility getVisibility(); - boolean isPlatform(); + boolean isHeader(); boolean isImpl(); diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeAliasDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeAliasDescriptor.kt index b5d989754e5..072b8c7a4f5 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeAliasDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeAliasDescriptor.kt @@ -65,7 +65,7 @@ abstract class AbstractTypeAliasDescriptor( override fun getVisibility() = visibilityImpl - override fun isPlatform(): Boolean = false + override fun isHeader(): Boolean = false override fun isImpl(): Boolean = false diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java index e34c9ea9173..12c127c7d83 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java @@ -115,7 +115,7 @@ public class ClassDescriptorImpl extends ClassDescriptorBase { } @Override - public boolean isPlatform() { + public boolean isHeader() { return false; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java index 2e46fc628ed..9d2b0f7b122 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java @@ -155,7 +155,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase { } @Override - public boolean isPlatform() { + public boolean isHeader() { return false; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java index 421df1a0d1a..adc907b4a1d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java @@ -43,7 +43,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo private boolean isExternal = false; private boolean isInline = false; private boolean isTailrec = false; - private boolean isPlatform = false; + private boolean isHeader = false; private boolean isImpl = false; // Difference between these hidden kinds: // 1. isHiddenToOvercomeSignatureClash prohibit calling such functions even in super-call context @@ -136,8 +136,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo this.isTailrec = isTailrec; } - public void setPlatform(boolean isPlatform) { - this.isPlatform = isPlatform; + public void setHeader(boolean isHeader) { + this.isHeader = isHeader; } public void setImpl(boolean isImpl) { @@ -258,8 +258,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo } @Override - public boolean isPlatform() { - return isPlatform; + public boolean isHeader() { + return isHeader; } @Override @@ -651,7 +651,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo substitutedDescriptor.setInline(isInline); substitutedDescriptor.setTailrec(isTailrec); substitutedDescriptor.setSuspend(isSuspend); - substitutedDescriptor.setPlatform(isPlatform); + substitutedDescriptor.setHeader(isHeader); substitutedDescriptor.setImpl(isImpl); substitutedDescriptor.setHasStableParameterNames(hasStableParameterNames); substitutedDescriptor.setHiddenToOvercomeSignatureClash(configuration.isHiddenToOvercomeSignatureClash); diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java index ae222c1db5f..a89d66e861b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java @@ -227,8 +227,8 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { } @Override - public boolean isPlatform() { - return original.isPlatform(); + public boolean isHeader() { + return original.isHeader(); } @Override diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java index 55feac40908..d5ed8135187 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java @@ -103,7 +103,7 @@ public abstract class PropertyAccessorDescriptorImpl extends DeclarationDescript } @Override - public boolean isPlatform() { + public boolean isHeader() { return false; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java index 8cd0d497183..ed34c455074 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java @@ -44,7 +44,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp private final Kind kind; private final boolean lateInit; private final boolean isConst; - private final boolean isPlatform; + private final boolean isHeader; private final boolean isImpl; private final boolean isExternal; @@ -67,7 +67,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp @NotNull SourceElement source, boolean lateInit, boolean isConst, - boolean isPlatform, + boolean isHeader, boolean isImpl, boolean isExternal ) { @@ -78,7 +78,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp this.kind = kind; this.lateInit = lateInit; this.isConst = isConst; - this.isPlatform = isPlatform; + this.isHeader = isHeader; this.isImpl = isImpl; this.isExternal = isExternal; } @@ -95,13 +95,13 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp @NotNull SourceElement source, boolean lateInit, boolean isConst, - boolean isPlatform, + boolean isHeader, boolean isImpl, boolean isExternal ) { return new PropertyDescriptorImpl(containingDeclaration, null, annotations, modality, visibility, isVar, name, kind, source, lateInit, isConst, - isPlatform, isImpl, isExternal); + isHeader, isImpl, isExternal); } public void setType( @@ -352,7 +352,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp ) { return new PropertyDescriptorImpl( newOwner, original, getAnnotations(), newModality, newVisibility, isVar(), getName(), kind, SourceElement.NO_SOURCE, - isLateInit(), isConst(), isPlatform(), isImpl(), isExternal() + isLateInit(), isConst(), isHeader(), isImpl(), isExternal() ); } @@ -374,8 +374,8 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp } @Override - public boolean isPlatform() { - return isPlatform; + public boolean isHeader() { + return isHeader; } @Override diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt index b292944e559..8c4cd9936ff 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt @@ -265,7 +265,7 @@ enum class DescriptorRendererModifier(val includeByDefault: Boolean) { INNER(true), MEMBER_KIND(true), DATA(true), - PLATFORM(true), + HEADER(true), IMPL(true), ; diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index 8e851b0a7d4..4e27dd39ae2 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -461,10 +461,10 @@ internal class DescriptorRendererImpl( builder.append(renderKeyword(keyword)).append(" ") } - private fun renderPlatform(isPlatform: Boolean, builder: StringBuilder) { - if (DescriptorRendererModifier.PLATFORM !in modifiers) return - if (isPlatform) { - builder.append(renderKeyword("platform")).append(" ") + private fun renderHeader(isHeader: Boolean, builder: StringBuilder) { + if (DescriptorRendererModifier.HEADER !in modifiers) return + if (isHeader) { + builder.append(renderKeyword("header")).append(" ") } } @@ -544,8 +544,8 @@ internal class DescriptorRendererImpl( if (functionDescriptor.isSuspend) { builder.append("suspend ") } - if (functionDescriptor.isPlatform) { - builder.append("platform ") + if (functionDescriptor.isHeader) { + builder.append("header ") } if (functionDescriptor.isImpl) { builder.append("impl ") @@ -910,7 +910,7 @@ internal class DescriptorRendererImpl( klass.kind.isSingleton && klass.modality == Modality.FINAL)) { renderModality(klass.modality, builder) } - renderPlatform(klass.isPlatform, builder) + renderHeader(klass.isHeader, builder) renderImpl(klass.isImpl, builder) renderInner(klass.isInner, builder) renderData(klass.isData, builder) diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java index 5aaee03eff1..4ec981ad35a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java @@ -368,7 +368,7 @@ public class ErrorUtils { SourceElement.NO_SOURCE, /* lateInit = */ false, /* isConst = */ false, - /* isPlatform = */ false, + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ); diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/NotFoundClasses.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/NotFoundClasses.kt index 0fe9b620281..1b560799624 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/NotFoundClasses.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/NotFoundClasses.kt @@ -100,7 +100,7 @@ class NotFoundClasses(private val storageManager: StorageManager, private val mo override fun isCompanionObject() = false override fun isData() = false - override fun isPlatform() = false + override fun isHeader() = false override fun isImpl() = false override fun isExternal() = false override val annotations: Annotations get() = Annotations.EMPTY diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index a68d904d20f..cfb8c085f82 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt @@ -95,7 +95,7 @@ class DeserializedClassDescriptor( override fun isData() = Flags.IS_DATA.get(classProto.flags) - override fun isPlatform() = false + override fun isHeader() = false override fun isImpl() = false diff --git a/idea/idea-completion/testData/keywords/AfterClassProperty.kt b/idea/idea-completion/testData/keywords/AfterClassProperty.kt index 869eee7d84f..960d53e7aa0 100644 --- a/idea/idea-completion/testData/keywords/AfterClassProperty.kt +++ b/idea/idea-completion/testData/keywords/AfterClassProperty.kt @@ -42,6 +42,6 @@ class MouseMovedEventArgs // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/AfterClasses.kt b/idea/idea-completion/testData/keywords/AfterClasses.kt index e999c984ecc..eb12039fe67 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses.kt @@ -36,6 +36,6 @@ class B { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/AfterFuns.kt b/idea/idea-completion/testData/keywords/AfterFuns.kt index 2931265247e..3e40ae69b76 100644 --- a/idea/idea-completion/testData/keywords/AfterFuns.kt +++ b/idea/idea-completion/testData/keywords/AfterFuns.kt @@ -41,6 +41,6 @@ class A { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt index ec62637d5a6..06cb86035d9 100644 --- a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt +++ b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt @@ -40,6 +40,6 @@ var a : Int // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt b/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt index ae951c0dac5..3107c56e48b 100644 --- a/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt +++ b/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt @@ -27,6 +27,6 @@ annotation class Test { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt index 22c472d250a..2d96475ec83 100644 --- a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt +++ b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt @@ -39,6 +39,6 @@ public class Test { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/InClassScope.kt b/idea/idea-completion/testData/keywords/InClassScope.kt index f3171fd58e1..42718e17b6b 100644 --- a/idea/idea-completion/testData/keywords/InClassScope.kt +++ b/idea/idea-completion/testData/keywords/InClassScope.kt @@ -33,6 +33,6 @@ class TestClass { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/InEnumScope2.kt b/idea/idea-completion/testData/keywords/InEnumScope2.kt index ff3fa657e33..e63f517f2df 100644 --- a/idea/idea-completion/testData/keywords/InEnumScope2.kt +++ b/idea/idea-completion/testData/keywords/InEnumScope2.kt @@ -28,7 +28,7 @@ enum class Test { // EXIST: suspend // EXIST: fun // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl /* TODO: items below are not valid here */ diff --git a/idea/idea-completion/testData/keywords/InInterfaceScope.kt b/idea/idea-completion/testData/keywords/InInterfaceScope.kt index fbcd3b4f277..011a6e3d070 100644 --- a/idea/idea-completion/testData/keywords/InInterfaceScope.kt +++ b/idea/idea-completion/testData/keywords/InInterfaceScope.kt @@ -29,6 +29,6 @@ interface Test { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/InObjectScope.kt b/idea/idea-completion/testData/keywords/InObjectScope.kt index 260299b7a22..b3fd60d167f 100644 --- a/idea/idea-completion/testData/keywords/InObjectScope.kt +++ b/idea/idea-completion/testData/keywords/InObjectScope.kt @@ -30,6 +30,6 @@ object Test { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt index e616b6f631a..dea8c50daf6 100644 --- a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt +++ b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt @@ -27,6 +27,6 @@ package Test // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/PrefixMatcher.kt b/idea/idea-completion/testData/keywords/PrefixMatcher.kt index d28f55cb408..5bb452ebe6e 100644 --- a/idea/idea-completion/testData/keywords/PrefixMatcher.kt +++ b/idea/idea-completion/testData/keywords/PrefixMatcher.kt @@ -5,5 +5,5 @@ p // EXIST: package // EXIST: private // EXIST: public -// EXIST: platform +// EXIST: header // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors.kt b/idea/idea-completion/testData/keywords/PropertyAccessors.kt index c967f84c986..83144925e43 100644 --- a/idea/idea-completion/testData/keywords/PropertyAccessors.kt +++ b/idea/idea-completion/testData/keywords/PropertyAccessors.kt @@ -41,6 +41,6 @@ class Some { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt index 8912263137e..74bf2304b4b 100644 --- a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt +++ b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt @@ -41,6 +41,6 @@ class Some { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/PropertySetter.kt b/idea/idea-completion/testData/keywords/PropertySetter.kt index af78bbc463f..9f6a61afa35 100644 --- a/idea/idea-completion/testData/keywords/PropertySetter.kt +++ b/idea/idea-completion/testData/keywords/PropertySetter.kt @@ -39,6 +39,6 @@ class Some { // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/idea/idea-completion/testData/keywords/TopScope.kt b/idea/idea-completion/testData/keywords/TopScope.kt index f235291323d..1793dbb9349 100644 --- a/idea/idea-completion/testData/keywords/TopScope.kt +++ b/idea/idea-completion/testData/keywords/TopScope.kt @@ -26,6 +26,6 @@ // EXIST: const // EXIST: suspend // EXIST: typealias -// EXIST: platform +// EXIST: header // EXIST: impl // NOTHING_ELSE diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt index 14773d44a73..7a30e3b2719 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.IdentifierChecker import org.jetbrains.kotlin.resolve.OverloadFilter import org.jetbrains.kotlin.resolve.PlatformConfigurator import org.jetbrains.kotlin.resolve.calls.checkers.ReifiedTypeParameterSubstitutionChecker -import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker +import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker import org.jetbrains.kotlin.resolve.scopes.SyntheticConstructorsProvider import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes import org.jetbrains.kotlin.types.DynamicTypesAllowed @@ -35,9 +35,10 @@ object JsPlatformConfigurator : PlatformConfigurator( additionalDeclarationCheckers = listOf( NativeInvokeChecker(), NativeGetterChecker(), NativeSetterChecker(), JsNameChecker, JsModuleChecker, - PlatformImplDeclarationChecker(), JsExternalChecker(), - JsRuntimeAnnotationChecker + JsRuntimeAnnotationChecker, + HeaderImplDeclarationChecker(), + JsExternalChecker() ), additionalCallCheckers = listOf(ReifiedTypeParameterSubstitutionChecker(), JsModuleCallChecker, JsDynamicCallChecker), additionalTypeCheckers = listOf(), diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsNameClashChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsNameClashChecker.kt index 1573bd5bf7a..fa643b502bd 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsNameClashChecker.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsNameClashChecker.kt @@ -55,7 +55,7 @@ class JsNameClashChecker : SimpleDeclarationChecker { val scope = getScope(suggested.scope) val name = suggested.names.last() val existing = scope[name] - if (existing != null && existing != suggested.descriptor && !(existing is MemberDescriptor && existing.isPlatform)) { + if (existing != null && existing != suggested.descriptor && !(existing is MemberDescriptor && existing.isHeader)) { diagnosticHolder.report(ErrorsJs.JS_NAME_CLASH.on(declaration, name, existing)) val existingDeclaration = existing.findPsi() if (clashedDescriptors.add(existing) && existingDeclaration is KtDeclaration && existingDeclaration != declaration) { diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java index 0896f485e92..e9828ecc5be 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java @@ -160,7 +160,7 @@ public final class AnnotationsUtils { } public static boolean isPredefinedObject(@NotNull DeclarationDescriptor descriptor) { - if (descriptor instanceof MemberDescriptor && ((MemberDescriptor) descriptor).isPlatform()) return true; + if (descriptor instanceof MemberDescriptor && ((MemberDescriptor) descriptor).isHeader()) return true; if (isEffectivelyExternal(descriptor)) return true; for (PredefinedAnnotation annotation : PredefinedAnnotation.values()) { diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/res/syntheticDescriptorGeneration.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/res/syntheticDescriptorGeneration.kt index 6cfabccf46b..951107219c2 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/res/syntheticDescriptorGeneration.kt +++ b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/res/syntheticDescriptorGeneration.kt @@ -103,7 +103,7 @@ private fun genProperty( sourceElement, /* lateinit = */ false, /* isConst = */ false, - /* isPlatform = */ false, + /* isHeader = */ false, /* isImpl = */ false, /* isExternal = */ false ) {