[ULC] Fixed invalid UL facade annotations

1) Hide annotations for MultiFile class
2) Remove nullability for private fields

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/ultraKtLightClassForFacade.kt

@@ -7,15 +7,16 @@ package org.jetbrains.kotlin.asJava.classes
 
 import com.intellij.psi.*
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+import com.intellij.psi.impl.light.LightModifierList
 import com.intellij.psi.util.CachedValue
 import org.jetbrains.kotlin.asJava.builder.LightClassData
 import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
 import org.jetbrains.kotlin.asJava.elements.*
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil.JVM_MULTIFILE_CLASS_SHORT
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil.findAnnotationEntryOnFileNoResolve
+import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.SpecialNames.NO_NAME_PROVIDED
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtProperty
@@ -39,25 +40,32 @@ class KtUltraLightClassForFacade(
 
     override val javaFileStub: PsiJavaFileStub? = null
 
-    private val _modifierList: PsiModifierList =
+    private val _modifierList: PsiModifierList by lazyPub {
-        KtUltraLightSimpleModifierList(owner = this, modifiers = setOf(PsiModifier.PUBLIC, PsiModifier.FINAL))
+        if (isMultiFileClass)
+            LightModifierList(manager, KotlinLanguage.INSTANCE, PsiModifier.PUBLIC, PsiModifier.FINAL)
+        else
+            KtUltraLightSimpleModifierList(owner = this, modifiers = setOf(PsiModifier.PUBLIC, PsiModifier.FINAL))
+    }
+
+    private val isMultiFileClass: Boolean by lazyPub {
+        files.size > 1 || files.any { findAnnotationEntryOnFileNoResolve(it, JVM_MULTIFILE_CLASS_SHORT) != null }
+    }
 
     private val _givenAnnotations: List<KtLightAbstractAnnotation>? by lazyPub {
         files.flatMap { file ->
-            file.annotationEntries.mapNotNull { entry ->
+            file.annotationEntries.map { entry ->
-                entry.analyzeAnnotation()?.fqName?.let { fqName ->
+                KtLightAnnotationForSourceEntry(
-                    KtLightAnnotationForSourceEntry(
+                    lazyQualifiedName = { entry.analyzeAnnotation()?.fqName?.asString() },
-                        qualifiedName = fqName.asString(),
+                    kotlinOrigin = entry,
-                        kotlinOrigin = entry,
+                    parent = _modifierList,
-                        parent = _modifierList,
+                    lazyClsDelegate = null
-                        lazyClsDelegate = null
+                )
-                    )
-                }
             }
         }
     }
 
-    override val givenAnnotations: List<KtLightAbstractAnnotation>? get() = _givenAnnotations
+    override val givenAnnotations: List<KtLightAbstractAnnotation>?
+        get() = if (isMultiFileClass) emptyList() else _givenAnnotations
 
     override fun getModifierList(): PsiModifierList = _modifierList
 

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/ultraLightAnnotations.kt

@@ -5,12 +5,11 @@
 
 package org.jetbrains.kotlin.asJava.classes
 
-import com.intellij.lang.jvm.JvmModifier
 import com.intellij.psi.*
 import com.intellij.psi.impl.PsiImplUtil
 import com.intellij.psi.impl.light.LightIdentifier
-import com.intellij.psi.meta.PsiMetaData
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
+import org.jetbrains.kotlin.asJava.elements.KtLightAnnotationForSourceEntry
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.asJava.elements.KtLightNullabilityAnnotation
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -50,8 +49,6 @@ class KtUltraLightSimpleAnnotation(
 ) : KtLightAbstractAnnotation(parent, computeDelegate = null) {
     override fun getNameReferenceElement(): PsiJavaCodeReferenceElement? = null
 
-    override fun getMetaData(): PsiMetaData? = null
-
     private val parameterList = ParameterListImpl()
 
     override fun getParameterList(): PsiAnnotationParameterList = parameterList
@@ -134,11 +131,4 @@ private class KtUltraLightPsiArrayInitializerMemberValue(
     override fun isPhysical(): Boolean = false
 
     override fun getText(): String = "{" + initializers.joinToString { it.text } + "}"
-}
+}
-
-fun PsiModifierListOwner.isPrivateOrParameterInPrivateMethod(): Boolean {
-    if (hasModifier(JvmModifier.PRIVATE)) return true
-    if (this !is PsiParameter) return false
-    val parentMethod = declarationScope as? PsiMethod ?: return false
-    return parentMethod.hasModifier(JvmModifier.PRIVATE)
-}

compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt

@@ -181,7 +181,7 @@ private fun lightAnnotationsForEntries(lightModifierList: KtLightModifierList<*>
                     }
                 } else null
 
-                KtLightAnnotationForSourceEntry(fqName, entry, lightModifierList, lazyClsDelegate)
+                KtLightAnnotationForSourceEntry({ fqName }, entry, lightModifierList, lazyClsDelegate)
             }
         }
 }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt

@@ -233,7 +233,9 @@ fun fastCheckIsNullabilityApplied(lightElement: KtLightElement<*, PsiModifierLis
     // all data-class generated members are not-null
     if (annotatedElement is KtClass && annotatedElement.isData()) return true
 
-    if (annotatedElement is KtParameter && lightElement !is PsiField) { //KtParameter but not it's backing field
+    if (lightElement is PsiField && lightElement.hasModifierProperty(PsiModifier.PRIVATE)) return false
+
+    if (annotatedElement is KtParameter) {
         val containingClassOrObject = annotatedElement.containingClassOrObject
         if (containingClassOrObject?.isAnnotation() == true) return false
         if ((containingClassOrObject as? KtClass)?.isEnum() == true) {