Add UL support for NoArg compiler plugin

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

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.asJava
+
+import org.jetbrains.kotlin.asJava.classes.KtUltraLightClass
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.psi.KtDeclaration
+
+interface UltraLightClassCodegenSupport {
+    fun interceptMethodsBuilding(
+        declaration: KtDeclaration,
+        descriptor: Lazy<DeclarationDescriptor?>,
+        containingDeclaration: KtUltraLightClass,
+        methodsList: MutableList<KtLightMethod>
+    ) = Unit
+}

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

@@ -14,6 +14,7 @@ import com.intellij.psi.impl.light.LightMethodBuilder
 import com.intellij.psi.util.CachedValue
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
+import org.jetbrains.kotlin.asJava.UltraLightClassCodegenSupport
 import org.jetbrains.kotlin.asJava.builder.LightClassData
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
@@ -22,6 +23,7 @@ import org.jetbrains.kotlin.backend.common.CodegenUtil
 import org.jetbrains.kotlin.backend.common.DataClassMethodGenerator
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil
+import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.codegen.kotlinType
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
@@ -267,7 +269,7 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
     private fun propertyParameters() = classOrObject.primaryConstructorParameters.filter { it.hasValOrVar() }
 
     private fun ownMethods(): List<KtLightMethod> {
-        val result = arrayListOf<KtLightMethod>()
+        val result = mutableListOf<KtLightMethod>()
 
         for (declaration in this.classOrObject.declarations.filterNot { it.isHiddenByDeprecation(support) }) {
             if (declaration.hasModifier(PRIVATE_KEYWORD) && isInterface) continue
@@ -315,6 +317,14 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
         addMethodsFromDataClass(result)
         addDelegatesToInterfaceMethods(result)
 
+        val lazyDescriptor = lazy { getDescriptor() }
+
+        ExpressionCodegenExtension.getInstances(project).forEach {
+            if (it is UltraLightClassCodegenSupport) {
+                it.interceptMethodsBuilding(kotlinOrigin, lazyDescriptor, this, result)
+            }
+        }
+
         return result
     }
 

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

@@ -241,9 +241,14 @@ fun KtUltraLightClass.createGeneratedMethodFromDescriptor(
         lightMethod.addParameter(KtUltraLightParameterForDescriptor(valueParameter, support, wrapper))
     }
 
-    lightMethod.setMethodReturnType {
+    if (descriptor is ConstructorDescriptor) {
-        support.mapType(wrapper) { typeMapper, signatureWriter ->
+        lightMethod.isConstructor = true
-            typeMapper.mapReturnType(descriptor, signatureWriter)
+        lightMethod.setMethodReturnType(PsiType.VOID)
+    } else {
+        lightMethod.setMethodReturnType {
+            support.mapType(wrapper) { typeMapper, signatureWriter ->
+                typeMapper.mapReturnType(descriptor, signatureWriter)
+            }
         }
     }
 
@@ -253,7 +258,7 @@ fun KtUltraLightClass.createGeneratedMethodFromDescriptor(
 private fun KtUltraLightClass.lightMethod(
     descriptor: FunctionDescriptor
 ): LightMethodBuilder {
-    val name = support.typeMapper.mapFunctionName(descriptor, OwnerKind.IMPLEMENTATION)
+    val name = if (descriptor is ConstructorDescriptor) name else support.typeMapper.mapFunctionName(descriptor, OwnerKind.IMPLEMENTATION)
 
     val accessFlags: Int by lazyPub {
         val asmFlags = AsmUtil.getMethodAsmFlags(descriptor, OwnerKind.IMPLEMENTATION, support.deprecationResolver)

plugins/annotation-based-compiler-plugins-ide-support/src/AnnotationBasedLightClassApplicabilityExtension.kt

@@ -28,18 +28,21 @@ abstract class AnnotationBasedLightClassApplicabilityExtension(project: Project,
         cachedAnnotationsNames.getAnnotationNames(modifierListOwner)
 
     override fun checkApplicabilityType(declaration: KtDeclaration, descriptor: Lazy<DeclarationDescriptor?>): LightClassApplicabilityType {
-        if (!declaration.isOrdinaryClass || !declaration.isAnnotated) return UltraLightClass
 
-        if (cachedAnnotationsNames.getAnnotationNames(declaration).isEmpty()) return UltraLightClass
+        return UltraLightClass
-
+//
-        val descriptorValue = descriptor.value ?: return UltraLightClass
+//        if (!declaration.isOrdinaryClass || !declaration.isAnnotated) return UltraLightClass
-
+//
-        val classDescriptor = (descriptorValue as? ClassDescriptor)
+//        if (cachedAnnotationsNames.getAnnotationNames(declaration).isEmpty()) return UltraLightClass
-            ?: descriptorValue.containingDeclaration as? ClassDescriptor
+//
-            ?: return UltraLightClass
+//        val descriptorValue = descriptor.value ?: return UltraLightClass
-
+//
-        val hasSpecialAnnotation = run { classDescriptor.hasSpecialAnnotation(declaration) }
+//        val classDescriptor = (descriptorValue as? ClassDescriptor)
-
+//            ?: descriptorValue.containingDeclaration as? ClassDescriptor
-        return if (hasSpecialAnnotation) LightClass else UltraLightClass
+//            ?: return UltraLightClass
+//
+//        val hasSpecialAnnotation = run { classDescriptor.hasSpecialAnnotation(declaration) }
+//
+//        return if (hasSpecialAnnotation) LightClass else UltraLightClass
     }
 }

plugins/noarg/noarg-cli/src/AbstractNoArgExpressionCodegenExtension.kt

@@ -72,7 +72,7 @@ abstract class AbstractNoArgExpressionCodegenExtension(val invokeInitializers: B
         })
     }
 
-    private fun createNoArgConstructorDescriptor(containingClass: ClassDescriptor): ConstructorDescriptor {
+    protected fun createNoArgConstructorDescriptor(containingClass: ClassDescriptor): ConstructorDescriptor {
         return ClassConstructorDescriptorImpl.createSynthesized(containingClass, Annotations.EMPTY, false, SourceElement.NO_SOURCE).apply {
             initialize(
                 null, calculateDispatchReceiverParameter(), emptyList(), emptyList(),

plugins/noarg/noarg-ide/build.gradle.kts

@@ -43,6 +43,8 @@ dependencies {
     testRuntimeOnly(intellijDep())
 
     Platform[192].orHigher {
+        compileOnly(intellijPluginDep("java"))
+
         testCompileOnly(intellijPluginDep("java"))
         testRuntimeOnly(intellijPluginDep("java"))
     }

plugins/noarg/noarg-ide/src/IdeArgExpressionCodegenExtension.kt

@@ -8,14 +8,49 @@ package org.jetbrains.kotlin.noarg.ide
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.annotation.plugin.ide.CachedAnnotationNames
 import org.jetbrains.kotlin.annotation.plugin.ide.getAnnotationNames
+import org.jetbrains.kotlin.asJava.UltraLightClassCodegenSupport
+import org.jetbrains.kotlin.asJava.classes.KtUltraLightClass
+import org.jetbrains.kotlin.asJava.classes.createGeneratedMethodFromDescriptor
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.noarg.AbstractNoArgExpressionCodegenExtension
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtModifierListOwner
+import org.jetbrains.kotlin.util.isAnnotated
+import org.jetbrains.kotlin.util.isOrdinaryClass
 
 class IdeNoArgExpressionCodegenExtension(project: Project) :
-    AbstractNoArgExpressionCodegenExtension(invokeInitializers = false) {
+    AbstractNoArgExpressionCodegenExtension(invokeInitializers = false),
+    UltraLightClassCodegenSupport {
 
     private val cachedAnnotationsNames = CachedAnnotationNames(project, NO_ARG_ANNOTATION_OPTION_PREFIX)
 
     override fun getAnnotationFqNames(modifierListOwner: KtModifierListOwner?): List<String> =
         cachedAnnotationsNames.getAnnotationNames(modifierListOwner)
+
+    override fun interceptMethodsBuilding(
+        declaration: KtDeclaration,
+        descriptor: Lazy<DeclarationDescriptor?>,
+        containingDeclaration: KtUltraLightClass,
+        methodsList: MutableList<KtLightMethod>
+    ) {
+        if (!declaration.isOrdinaryClass || !declaration.isAnnotated) return
+
+        if (cachedAnnotationsNames.getAnnotationNames(declaration).isEmpty()) return
+
+        val descriptorValue = descriptor.value ?: return
+
+        val classDescriptor = (descriptorValue as? ClassDescriptor)
+            ?: descriptorValue.containingDeclaration as? ClassDescriptor
+            ?: return
+
+        if (!run { classDescriptor.hasSpecialAnnotation(declaration) }) return
+
+        val parentClass = containingDeclaration as? KtUltraLightClass ?: return
+
+        val constructorDescriptor = createNoArgConstructorDescriptor(classDescriptor)
+
+        methodsList.add(parentClass.createGeneratedMethodFromDescriptor(constructorDescriptor))
+    }
 }

plugins/noarg/noarg-ide/test/org/jetbrains/kotlin/noarg/TestNoArgForLightClass.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.noarg
 
 import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.kotlin.config.LanguageVersion
-import org.jetbrains.kotlin.idea.caches.resolve.analyzeWithAllCompilerChecks
 import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinProjectDescriptorWithFacet