Migration to expect/actual: highlighter markers

idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/PlatformHeaderAnnotator.kt

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker
+import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.diagnostics.SimpleDiagnostics
 
 val ModuleDescriptor.sourceKind: SourceKind
@@ -68,7 +68,7 @@ class PlatformHeaderAnnotator : Annotator {
 
         val trace = BindingTraceContext()
         for (module in implementingModules) {
-            HeaderImplDeclarationChecker.checkHeaderDeclarationHasImplementation(declaration, descriptor, trace, module)
+            ExpectedActualDeclarationChecker.checkExpectedDeclarationHasActual(declaration, descriptor, trace, module)
         }
 
         val suppressionCache = KotlinCacheService.getInstance(declaration.project).getSuppressionCache()

idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/KotlinMultiplatformJUnitRecognizer.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
 import org.jetbrains.kotlin.idea.highlighter.allImplementingCompatibleModules
-import org.jetbrains.kotlin.idea.highlighter.markers.implementationsOf
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsFor
 import org.jetbrains.kotlin.idea.project.targetPlatform
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -57,7 +57,7 @@ private fun AnnotationWithTarget.isExpectOfAnnotation(fqName: String, implModule
 
     return implModules
         .any { module ->
-            module.implementationsOf(annotationClass, checkCompatible = false)
+            module.actualsFor(annotationClass, checkCompatible = false)
                 .filterIsInstance<TypeAliasDescriptor>()
                 .any { it.classDescriptor?.fqNameSafe?.asString() == fqName }
         }

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/HasActualMarker.kt

@@ -26,66 +26,66 @@ import org.jetbrains.kotlin.idea.highlighter.allImplementingCompatibleModules
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.MultiTargetPlatform
-import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker
+import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
 import java.awt.event.MouseEvent
 
-fun ModuleDescriptor.hasImplementationsOf(descriptor: MemberDescriptor) =
+fun ModuleDescriptor.hasActualsFor(descriptor: MemberDescriptor) =
-        implementationsOf(descriptor).isNotEmpty()
+        actualsFor(descriptor).isNotEmpty()
 
-fun ModuleDescriptor.implementationsOf(descriptor: MemberDescriptor, checkCompatible: Boolean = true): List<DeclarationDescriptor> =
+fun ModuleDescriptor.actualsFor(descriptor: MemberDescriptor, checkCompatible: Boolean = true): List<DeclarationDescriptor> =
-        with(HeaderImplDeclarationChecker) {
+        with(ExpectedActualDeclarationChecker) {
             if (checkCompatible) {
-                descriptor.findCompatibleImplForHeader(this@implementationsOf)
+                descriptor.findCompatibleActualForExpected(this@actualsFor)
             }
             else {
-                descriptor.findAnyImplForHeader(this@implementationsOf)
+                descriptor.findAnyActualForExpected(this@actualsFor)
             }
         }
 
-fun getPlatformImplementationTooltip(declaration: KtDeclaration): String? {
+fun getPlatformActualTooltip(declaration: KtDeclaration): String? {
     val descriptor = declaration.toDescriptor() as? MemberDescriptor ?: return null
     val commonModuleDescriptor = declaration.containingKtFile.findModuleDescriptor()
 
-    val platformModulesWithImplementation = commonModuleDescriptor.allImplementingCompatibleModules.filter {
+    val platformModulesWithActuals = commonModuleDescriptor.allImplementingCompatibleModules.filter {
-        it.hasImplementationsOf(descriptor)
+        it.hasActualsFor(descriptor)
     }
-    if (platformModulesWithImplementation.isEmpty()) return null
+    if (platformModulesWithActuals.isEmpty()) return null
 
-    return platformModulesWithImplementation.joinToString(prefix = "Has implementations in ") {
+    return platformModulesWithActuals.joinToString(prefix = "Has actuals in ") {
         (it.getMultiTargetPlatform() as MultiTargetPlatform.Specific).platform
     }
 }
 
-fun navigateToPlatformImplementation(e: MouseEvent?, declaration: KtDeclaration) {
+fun navigateToPlatformActual(e: MouseEvent?, declaration: KtDeclaration) {
-    val implementations = declaration.headerImplementations()
+    val actuals = declaration.actualsForExpected()
-    if (implementations.isEmpty()) return
+    if (actuals.isEmpty()) return
 
     val renderer = DefaultPsiElementCellRenderer()
     PsiElementListNavigator.openTargets(e,
-                                        implementations.toTypedArray(),
+                                        actuals.toTypedArray(),
-                                        "Choose implementation of ${declaration.name}",
+                                        "Choose actual for ${declaration.name}",
-                                        "Implementations of ${declaration.name}",
+                                        "Actuals for ${declaration.name}",
                                         renderer)
 }
 
-private fun DeclarationDescriptor.headerImplementations(): Collection<DeclarationDescriptor> {
+private fun DeclarationDescriptor.actualsForExpected(): Collection<DeclarationDescriptor> {
     if (this is MemberDescriptor) {
         if (!this.isExpect) return emptyList()
 
-        return module.allImplementingCompatibleModules.flatMap { it.implementationsOf(this) }
+        return module.allImplementingCompatibleModules.flatMap { it.actualsFor(this) }
     }
 
     if (this is ValueParameterDescriptor) {
-        return containingDeclaration.headerImplementations().mapNotNull { (it as? CallableDescriptor)?.valueParameters?.getOrNull(index) }
+        return containingDeclaration.actualsForExpected().mapNotNull { (it as? CallableDescriptor)?.valueParameters?.getOrNull(index) }
     }
 
     return emptyList()
 }
 
-internal fun KtDeclaration.headerImplementations(): Set<KtDeclaration> {
+internal fun KtDeclaration.actualsForExpected(): Set<KtDeclaration> {
-    return unsafeResolveToDescriptor().headerImplementations().mapNotNullTo(LinkedHashSet()) {
+    return unsafeResolveToDescriptor().actualsForExpected().mapNotNullTo(LinkedHashSet()) {
         DescriptorToSourceUtils.descriptorToDeclaration(it) as? KtDeclaration
     }
 }

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/HasExpectedMarker.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.MultiTargetPlatform
-import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker
+import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.getMultiTargetPlatform
 
@@ -40,11 +40,11 @@ fun ModuleDescriptor.commonModuleOrNull(): ModuleDescriptor? {
 fun ModuleDescriptor.hasDeclarationOf(descriptor: MemberDescriptor) = declarationOf(descriptor) != null
 
 private fun ModuleDescriptor.declarationOf(descriptor: MemberDescriptor): DeclarationDescriptor? =
-        with(HeaderImplDeclarationChecker) {
+        with(ExpectedActualDeclarationChecker) {
-            descriptor.findCompatibleHeaderForImpl(this@declarationOf).firstOrNull()
+            descriptor.findCompatibleExpectedForActual(this@declarationOf).firstOrNull()
         }
 
-fun getHeaderDeclarationTooltip(declaration: KtDeclaration): String? {
+fun getExpectedDeclarationTooltip(declaration: KtDeclaration): String? {
     val descriptor = declaration.toDescriptor() as? MemberDescriptor ?: return null
     val platformModuleDescriptor = declaration.containingKtFile.findModuleDescriptor()
 
@@ -54,39 +54,39 @@ fun getHeaderDeclarationTooltip(declaration: KtDeclaration): String? {
     return "Has declaration in common module"
 }
 
-fun navigateToHeaderDeclaration(declaration: KtDeclaration) {
+fun navigateToExpectedDeclaration(declaration: KtDeclaration) {
-    declaration.headerDeclarationIfAny()?.navigate(false)
+    declaration.expectedDeclarationIfAny()?.navigate(false)
 }
 
-internal fun MemberDescriptor.headerDescriptor() = module.commonModuleOrNull()?.declarationOf(this)
+internal fun MemberDescriptor.expectedDescriptor() = module.commonModuleOrNull()?.declarationOf(this)
 
-internal fun KtDeclaration.headerDeclarationIfAny(): KtDeclaration? {
+internal fun KtDeclaration.expectedDeclarationIfAny(): KtDeclaration? {
-    val headerDescriptor = (toDescriptor() as? MemberDescriptor)?.headerDescriptor() ?: return null
+    val expectedDescriptor = (toDescriptor() as? MemberDescriptor)?.expectedDescriptor() ?: return null
-    return DescriptorToSourceUtils.descriptorToDeclaration(headerDescriptor) as? KtDeclaration
+    return DescriptorToSourceUtils.descriptorToDeclaration(expectedDescriptor) as? KtDeclaration
 }
 
-internal fun KtDeclaration.isExpectOrExpectClassMember() =
+internal fun KtDeclaration.isExpectedOrExpectedClassMember() =
         hasExpectModifier() || (containingClassOrObject?.hasExpectModifier() ?: false)
 
-internal fun DeclarationDescriptor.liftToHeader(): DeclarationDescriptor? {
+internal fun DeclarationDescriptor.liftToExpected(): DeclarationDescriptor? {
     if (this is MemberDescriptor) {
         return when {
             isExpect -> this
-            isActual -> headerDescriptor()
+            isActual -> expectedDescriptor()
             else -> null
         }
     }
 
     if (this is ValueParameterDescriptor) {
-        val containingHeaderDescriptor = containingDeclaration.liftToHeader() as? CallableDescriptor ?: return null
+        val containingExpectedDescriptor = containingDeclaration.liftToExpected() as? CallableDescriptor ?: return null
-        return containingHeaderDescriptor.valueParameters.getOrNull(index)
+        return containingExpectedDescriptor.valueParameters.getOrNull(index)
     }
 
     return null
 }
 
-internal fun KtDeclaration.liftToHeader(): KtDeclaration? {
+internal fun KtDeclaration.liftToExpected(): KtDeclaration? {
     val descriptor = resolveToDescriptorIfAny()
-    val headerDescriptor = descriptor?.liftToHeader() ?: return null
+    val expectedDescriptor = descriptor?.liftToExpected() ?: return null
-    return DescriptorToSourceUtils.descriptorToDeclaration(headerDescriptor) as? KtDeclaration
+    return DescriptorToSourceUtils.descriptorToDeclaration(expectedDescriptor) as? KtDeclaration
 }

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt

@@ -101,10 +101,10 @@ class KotlinLineMarkerProvider : LineMarkerProvider {
             if (element !is KtNamedDeclaration) continue
 
             if (element.hasExpectModifier()) {
-                collectImplementationMarkers(element, result)
+                collectActualMarkers(element, result)
             }
             else if (element.hasActualModifier()) {
-                collectHeaderMarkers(element, result)
+                collectExpectedMarkers(element, result)
             }
         }
     }
@@ -182,22 +182,22 @@ private val OVERRIDDEN_PROPERTY = object : MarkerType(
     }
 }
 
-private val PLATFORM_IMPLEMENTATION = MarkerType(
+private val PLATFORM_ACTUAL = MarkerType(
-        "PLATFORM_IMPLEMENTATION",
+        "PLATFORM_ACTUAL",
-        { it?.let { getPlatformImplementationTooltip(it.parent as KtDeclaration) } },
+        { it?.let { getPlatformActualTooltip(it.parent as KtDeclaration) } },
         object : LineMarkerNavigator() {
             override fun browse(e: MouseEvent?, element: PsiElement?) {
-                element?.let { navigateToPlatformImplementation(e, it.parent as KtDeclaration) }
+                element?.let { navigateToPlatformActual(e, it.parent as KtDeclaration) }
             }
         }
 )
 
-private val HEADER_DECLARATION = MarkerType(
+private val EXPECTED_DECLARATION = MarkerType(
-        "HEADER_DECLARATION",
+        "EXPECTED_DECLARATION",
-        { it?.let { getHeaderDeclarationTooltip(it.parent as KtDeclaration) } },
+        { it?.let { getExpectedDeclarationTooltip(it.parent as KtDeclaration) } },
         object : LineMarkerNavigator() {
             override fun browse(e: MouseEvent?, element: PsiElement?) {
-                element?.let { navigateToHeaderDeclaration(it.parent as KtDeclaration) }
+                element?.let { navigateToExpectedDeclaration(it.parent as KtDeclaration) }
             }
         }
 )
@@ -286,13 +286,13 @@ private fun collectOverriddenPropertyAccessors(properties: Collection<KtNamedDec
     }
 }
 
-private fun collectImplementationMarkers(declaration: KtNamedDeclaration,
+private fun collectActualMarkers(declaration: KtNamedDeclaration,
-                                         result: MutableCollection<LineMarkerInfo<*>>) {
+                                 result: MutableCollection<LineMarkerInfo<*>>) {
 
     val descriptor = declaration.toDescriptor() as? MemberDescriptor ?: return
     val commonModuleDescriptor = declaration.containingKtFile.findModuleDescriptor()
 
-    if (commonModuleDescriptor.allImplementingCompatibleModules.none { it.hasImplementationsOf(descriptor) }) return
+    if (commonModuleDescriptor.allImplementingCompatibleModules.none { it.hasActualsFor(descriptor) }) return
 
     val anchor = declaration.nameIdentifier ?: declaration
 
@@ -301,14 +301,14 @@ private fun collectImplementationMarkers(declaration: KtNamedDeclaration,
             anchor.textRange,
             KotlinIcons.FROM_HEADER,
             Pass.LINE_MARKERS,
-            PLATFORM_IMPLEMENTATION.tooltip,
+            PLATFORM_ACTUAL.tooltip,
-            PLATFORM_IMPLEMENTATION.navigationHandler,
+            PLATFORM_ACTUAL.navigationHandler,
             GutterIconRenderer.Alignment.RIGHT
     ))
 }
 
-private fun collectHeaderMarkers(declaration: KtNamedDeclaration,
+private fun collectExpectedMarkers(declaration: KtNamedDeclaration,
-                                 result: MutableCollection<LineMarkerInfo<*>>) {
+                                   result: MutableCollection<LineMarkerInfo<*>>) {
 
     val descriptor = declaration.toDescriptor() as? MemberDescriptor ?: return
     val platformModuleDescriptor = declaration.containingKtFile.findModuleDescriptor()
@@ -322,8 +322,8 @@ private fun collectHeaderMarkers(declaration: KtNamedDeclaration,
             anchor.textRange,
             KotlinIcons.FROM_IMPL,
             Pass.LINE_MARKERS,
-            HEADER_DECLARATION.tooltip,
+            EXPECTED_DECLARATION.tooltip,
-            HEADER_DECLARATION.navigationHandler,
+            EXPECTED_DECLARATION.navigationHandler,
             GutterIconRenderer.Alignment.RIGHT
     ))
 }

idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt

@@ -56,7 +56,7 @@ import org.jetbrains.kotlin.idea.core.toDescriptor
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.kotlin.idea.findUsages.handlers.KotlinFindClassUsagesHandler
 import org.jetbrains.kotlin.idea.highlighter.allImplementingCompatibleModules
-import org.jetbrains.kotlin.idea.highlighter.markers.hasImplementationsOf
+import org.jetbrains.kotlin.idea.highlighter.markers.hasActualsFor
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.references.resolveMainReferenceToDescriptors
@@ -334,8 +334,8 @@ class UnusedSymbolInspection : AbstractKotlinInspection() {
         descriptor as? MemberDescriptor ?: return false
         val commonModuleDescriptor = declaration.containingKtFile.findModuleDescriptor()
 
-        return commonModuleDescriptor.allImplementingCompatibleModules.any { it.hasImplementationsOf(descriptor) } ||
+        return commonModuleDescriptor.allImplementingCompatibleModules.any { it.hasActualsFor(descriptor) } ||
-               commonModuleDescriptor.hasImplementationsOf(descriptor)
+               commonModuleDescriptor.hasActualsFor(descriptor)
     }
 
     override fun createOptionsPanel(): JComponent? {

idea/src/org/jetbrains/kotlin/idea/intentions/declarations/ConvertMemberToExtensionIntention.kt

@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
 import org.jetbrains.kotlin.idea.core.*
-import org.jetbrains.kotlin.idea.highlighter.markers.headerImplementations
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsForExpected
-import org.jetbrains.kotlin.idea.highlighter.markers.isExpectOrExpectClassMember
+import org.jetbrains.kotlin.idea.highlighter.markers.isExpectedOrExpectedClassMember
-import org.jetbrains.kotlin.idea.highlighter.markers.liftToHeader
+import org.jetbrains.kotlin.idea.highlighter.markers.liftToExpected
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.getReturnTypeReference
 import org.jetbrains.kotlin.idea.refactoring.withHeaderImplementations
@@ -72,7 +72,7 @@ class ConvertMemberToExtensionIntention : SelfTargetingRangeIntention<KtCallable
     override fun applyTo(element: KtCallableDeclaration, editor: Editor?) {
         var allowHeader = true
 
-        element.liftToHeader()?.headerImplementations()?.let {
+        element.liftToExpected()?.actualsForExpected()?.let {
             if (it.isEmpty()) {
                 allowHeader = askIfHeaderIsAllowed(element.containingKtFile)
             }
@@ -111,7 +111,7 @@ class ConvertMemberToExtensionIntention : SelfTargetingRangeIntention<KtCallable
         val descriptor = element.unsafeResolveToDescriptor()
         val containingClass = descriptor.containingDeclaration as ClassDescriptor
 
-        val isEffectiveHeader = allowHeader && element.isExpectOrExpectClassMember()
+        val isEffectiveHeader = allowHeader && element.isExpectedOrExpectedClassMember()
 
         val file = element.containingKtFile
         val project = file.project
@@ -260,7 +260,7 @@ class ConvertMemberToExtensionIntention : SelfTargetingRangeIntention<KtCallable
             element: KtCallableDeclaration,
             allowHeader: Boolean = true
     ): Pair<KtCallableDeclaration, KtExpression?> {
-        val headerDeclaration = element.liftToHeader() as? KtCallableDeclaration
+        val headerDeclaration = element.liftToExpected() as? KtCallableDeclaration
         if (headerDeclaration != null) {
             element.withHeaderImplementations().filterIsInstance<KtCallableDeclaration>().forEach {
                 if (it != element) {

idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt

@@ -35,9 +35,9 @@ import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.getDeepestSuperDeclarations
 import org.jetbrains.kotlin.idea.core.getDirectlyOverriddenDeclarations
-import org.jetbrains.kotlin.idea.highlighter.markers.headerImplementations
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsForExpected
-import org.jetbrains.kotlin.idea.highlighter.markers.isExpectOrExpectClassMember
+import org.jetbrains.kotlin.idea.highlighter.markers.isExpectedOrExpectedClassMember
-import org.jetbrains.kotlin.idea.highlighter.markers.liftToHeader
+import org.jetbrains.kotlin.idea.highlighter.markers.liftToExpected
 import org.jetbrains.kotlin.idea.util.getResolutionScope
 import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -57,7 +57,7 @@ abstract class CallableRefactoring<out T: CallableDescriptor>(
     private val LOG = Logger.getInstance(CallableRefactoring::class.java)
 
     @Suppress("UNCHECKED_CAST")
-    val callableDescriptor = callableDescriptor.liftToHeader() as? T ?: callableDescriptor
+    val callableDescriptor = callableDescriptor.liftToExpected() as? T ?: callableDescriptor
 
     private val kind = (callableDescriptor as? CallableMemberDescriptor)?.kind ?: CallableMemberDescriptor.Kind.DECLARATION
 
@@ -76,7 +76,7 @@ abstract class CallableRefactoring<out T: CallableDescriptor>(
             else -> {
                 throw IllegalStateException("Unexpected callable kind: $kind")
             }
-        }.map { it.liftToHeader() as? CallableDescriptor ?: it }
+        }.map { it.liftToExpected() as? CallableDescriptor ?: it }
     }
 
     private fun showSuperFunctionWarningDialog(superCallables: Collection<CallableDescriptor>,
@@ -184,8 +184,8 @@ abstract class CallableRefactoring<out T: CallableDescriptor>(
 fun getAffectedCallables(project: Project, descriptorsForChange: Collection<CallableDescriptor>): List<PsiElement> {
     val baseCallables = descriptorsForChange.mapNotNull { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
     return baseCallables + baseCallables.flatMapTo(HashSet<PsiElement>()) { callable ->
-        if (callable is KtDeclaration && callable.isExpectOrExpectClassMember()) {
+        if (callable is KtDeclaration && callable.isExpectedOrExpectedClassMember()) {
-            callable.headerImplementations()
+            callable.actualsForExpected()
         }
         else {
             callable.toLightMethods().flatMap { psiMethod ->

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureData.kt

@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.highlighter.markers.headerImplementations
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsForExpected
-import org.jetbrains.kotlin.idea.highlighter.markers.isExpectOrExpectClassMember
+import org.jetbrains.kotlin.idea.highlighter.markers.isExpectedOrExpectedClassMember
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
@@ -98,8 +98,8 @@ class KotlinChangeSignatureData(
         primaryCallables + primaryCallables.flatMapTo(HashSet<UsageInfo>()) { primaryFunction ->
             val primaryDeclaration = primaryFunction.declaration as? KtDeclaration ?: return@flatMapTo emptyList()
 
-            if (primaryDeclaration.isExpectOrExpectClassMember()) {
+            if (primaryDeclaration.isExpectedOrExpectedClassMember()) {
-                return@flatMapTo primaryDeclaration.headerImplementations().mapNotNull {
+                return@flatMapTo primaryDeclaration.actualsForExpected().mapNotNull {
                     val descriptor = it.unsafeResolveToDescriptor()
                     val callableDescriptor = when (descriptor) {
                         is CallableDescriptor -> descriptor

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureHandler.kt

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZE
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.highlighter.markers.headerDescriptor
+import org.jetbrains.kotlin.idea.highlighter.markers.expectedDescriptor
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.psi.*
@@ -166,7 +166,7 @@ class KotlinChangeSignatureHandler : ChangeSignatureHandler {
 
             var descriptor = getDescriptor(bindingContext, element)
             if (descriptor is MemberDescriptor && descriptor.isActual) {
-                descriptor = descriptor.headerDescriptor() ?: descriptor
+                descriptor = descriptor.expectedDescriptor() ?: descriptor
             }
 
             return when (descriptor) {

idea/src/org/jetbrains/kotlin/idea/refactoring/kotlinRefactoringUtil.kt

@@ -77,8 +77,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.*
 import org.jetbrains.kotlin.idea.core.util.showYesNoCancelDialog
-import org.jetbrains.kotlin.idea.highlighter.markers.headerImplementations
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsForExpected
-import org.jetbrains.kotlin.idea.highlighter.markers.liftToHeader
+import org.jetbrains.kotlin.idea.highlighter.markers.liftToExpected
 import org.jetbrains.kotlin.idea.intentions.RemoveCurlyBracesFromTemplateIntention
 import org.jetbrains.kotlin.idea.j2k.IdeaJavaToKotlinServices
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinValVar
@@ -968,12 +968,12 @@ fun KtNamedDeclaration.isCompanionMemberOf(klass: KtClassOrObject): Boolean {
 }
 
 internal fun KtDeclaration.withHeaderImplementations(): List<KtDeclaration> {
-    val header = liftToHeader() ?: return listOf(this)
+    val header = liftToExpected() ?: return listOf(this)
-    val implementations = header.headerImplementations()
+    val implementations = header.actualsForExpected()
     return listOf(header) + implementations
 }
 
 internal fun KtDeclaration.resolveToHeaderDescriptorIfPossible(): DeclarationDescriptor {
     val descriptor = unsafeResolveToDescriptor()
-    return descriptor.liftToHeader() ?: descriptor
+    return descriptor.liftToExpected() ?: descriptor
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticOverloadsRenamer.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
-import org.jetbrains.kotlin.idea.highlighter.markers.headerDescriptor
+import org.jetbrains.kotlin.idea.highlighter.markers.expectedDescriptor
 import org.jetbrains.kotlin.idea.util.getAllAccessibleFunctions
 import org.jetbrains.kotlin.idea.util.getResolutionScope
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
@@ -68,7 +68,7 @@ private fun KtNamedFunction.getOverloads(): Collection<FunctionDescriptor> {
     val scope = getResolutionScope(context, resolutionFacade)
     val extensionReceiverClass = descriptor.extensionReceiverParameter?.type?.constructor?.declarationDescriptor as? ClassDescriptor
 
-    if (descriptor.isActual && descriptor.headerDescriptor() != null) return emptyList()
+    if (descriptor.isActual && descriptor.expectedDescriptor() != null) return emptyList()
 
     val result = LinkedHashSet<FunctionDescriptor>()
     result += scope.getAllAccessibleFunctions(name)

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
-import org.jetbrains.kotlin.idea.highlighter.markers.liftToHeader
+import org.jetbrains.kotlin.idea.highlighter.markers.liftToExpected
 import org.jetbrains.kotlin.idea.refactoring.Pass
 import org.jetbrains.kotlin.idea.refactoring.checkSuperMethods
 import org.jetbrains.kotlin.idea.refactoring.checkSuperMethodsWithPopup
@@ -108,7 +108,7 @@ class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() {
             get() = originalDeclaration
     }
 
-    private fun substituteForHeaderOrImpl(element: PsiElement?) = (element?.namedUnwrappedElement as? KtNamedDeclaration)?.liftToHeader()
+    private fun substituteForHeaderOrImpl(element: PsiElement?) = (element?.namedUnwrappedElement as? KtNamedDeclaration)?.liftToExpected()
 
     override fun substituteElementToRename(element: PsiElement?, editor: Editor?): PsiElement?  {
         substituteForHeaderOrImpl(element)?.let { return it }

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt

@@ -31,8 +31,8 @@ import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.quoteIfNeeded
-import org.jetbrains.kotlin.idea.highlighter.markers.headerImplementations
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsForExpected
-import org.jetbrains.kotlin.idea.highlighter.markers.liftToHeader
+import org.jetbrains.kotlin.idea.highlighter.markers.liftToExpected
 import org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinReferencesSearchOptions
 import org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinReferencesSearchParameters
 import org.jetbrains.kotlin.idea.search.projectScope
@@ -71,9 +71,9 @@ abstract class RenameKotlinPsiProcessor : RenamePsiElementProcessor() {
 
         val declaration = element.namedUnwrappedElement as? KtNamedDeclaration
         if (declaration != null) {
-            declaration.liftToHeader()?.let { headerDeclaration ->
+            declaration.liftToExpected()?.let { headerDeclaration ->
                 allRenames[headerDeclaration] = safeNewName
-                headerDeclaration.headerImplementations().forEach { allRenames[it] = safeNewName }
+                headerDeclaration.actualsForExpected().forEach { allRenames[it] = safeNewName }
             }
         }
     }

idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt

@@ -40,8 +40,8 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.idea.KotlinBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.deleteElementAndCleanParent
-import org.jetbrains.kotlin.idea.highlighter.markers.headerImplementations
+import org.jetbrains.kotlin.idea.highlighter.markers.actualsForExpected
-import org.jetbrains.kotlin.idea.highlighter.markers.liftToHeader
+import org.jetbrains.kotlin.idea.highlighter.markers.liftToExpected
 import org.jetbrains.kotlin.idea.refactoring.checkSuperMethods
 import org.jetbrains.kotlin.idea.refactoring.formatClass
 import org.jetbrains.kotlin.idea.refactoring.formatFunction
@@ -362,7 +362,7 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
 
     override fun prepareForDeletion(element: PsiElement) {
         if (element is KtDeclaration) {
-            element.headerImplementations().forEach {
+            element.actualsForExpected().forEach {
                 if (it is KtParameter) {
                     (it.parent as? KtParameterList)?.removeParameter(it)
                 }
@@ -415,7 +415,7 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
     ): Collection<PsiElement>? {
         when (element) {
             is KtParameter -> {
-                val headerParameter = element.liftToHeader() as? KtParameter
+                val headerParameter = element.liftToExpected() as? KtParameter
                 if (headerParameter != null && headerParameter != element) {
                     if (shouldAllowPropagationToHeader(element)) {
                         return listOf(headerParameter)

idea/testData/multiModuleLineMarker/withOverloads/common/common.kt

@@ -1,3 +1,3 @@
-header fun <lineMarker descr="Has implementations in JVM">foo</lineMarker>(): Int
+header fun <lineMarker descr="Has actuals in JVM">foo</lineMarker>(): Int
 
-header fun <lineMarker descr="Has implementations in JVM">foo</lineMarker>(arg: Int): Int
+header fun <lineMarker descr="Has actuals in JVM">foo</lineMarker>(arg: Int): Int