Support Java constructors in FIR (related to KT-29218)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -9,24 +9,24 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirCallableMember
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
+import org.jetbrains.kotlin.fir.expressions.FirCall
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
+import org.jetbrains.kotlin.fir.java.declarations.*
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
 import org.jetbrains.kotlin.fir.resolve.AbstractFirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 
 class JavaSymbolProvider(
@@ -44,17 +44,21 @@ class JavaSymbolProvider(
             val classId = callableId.classId ?: return@lookupCacheOrCalculate emptyList()
             val classSymbol = getClassLikeSymbolByFqName(classId) as? FirClassSymbol
                 ?: return@lookupCacheOrCalculate emptyList()
-            val firClass = classSymbol.fir as FirModifiableClass
+            val firClass = classSymbol.fir
             val callableSymbols = mutableListOf<ConeCallableSymbol>()
             for (declaration in firClass.declarations) {
-                when (declaration) {
+                val declarationId = when (declaration) {
-                    is FirCallableMember -> {
+                    is FirConstructor -> {
-                        val declarationId = CallableId(callableId.packageName, callableId.className, declaration.name)
+                        CallableId(callableId.packageName, callableId.className, firClass.name)
-                        if (declarationId == callableId) {
-                            val symbol = declaration.symbol as ConeCallableSymbol
-                            callableSymbols += symbol
-                        }
                     }
+                    is FirCallableMember -> {
+                        CallableId(callableId.packageName, callableId.className, declaration.name)
+                    }
+                    else -> null
+                }
+                if (declarationId == callableId) {
+                    val symbol = (declaration as FirCallableMember).symbol as ConeCallableSymbol
+                    callableSymbols += symbol
                 }
             }
             callableSymbols
@@ -118,18 +122,32 @@ class JavaSymbolProvider(
                             }
                             addAnnotationsFrom(javaMethod)
                             for (valueParameter in javaMethod.valueParameters) {
-                                val parameterType = valueParameter.type
+                                valueParameters += valueParameter.toFirValueParameters(session)
-                                valueParameters += FirJavaValueParameter(
-                                    session, valueParameter.name ?: Name.special("<anonymous Java parameter>"),
-                                    returnTypeRef = parameterType.toFirJavaTypeRef(session),
-                                    isVararg = valueParameter.isVararg
-                                ).apply {
-                                    addAnnotationsFrom(valueParameter)
-                                }
                             }
                         }
                         declarations += firJavaMethod
                     }
+                    for (javaConstructor in javaClass.constructors) {
+                        val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName)
+                        val constructorSymbol = FirFunctionSymbol(constructorId)
+                        val firJavaConstructor = FirJavaConstructor(
+                            session, constructorSymbol, javaConstructor.visibility,
+                            FirResolvedTypeRefImpl(
+                                session, null,
+                                firSymbol.constructType(emptyArray(), false),
+                                false, emptyList()
+                            )
+                        ).apply {
+                            for (typeParameter in javaConstructor.typeParameters) {
+                                typeParameters += createTypeParameterSymbol(session, typeParameter.name).fir
+                            }
+                            addAnnotationsFrom(javaConstructor)
+                            for (valueParameter in javaConstructor.valueParameters) {
+                                valueParameters += valueParameter.toFirValueParameters(session)
+                            }
+                        }
+                        declarations += firJavaConstructor
+                    }
                 }
             }
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -9,11 +9,13 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.*
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
@@ -176,6 +178,16 @@ internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(javaAnnotationOwner:
     }
 }
 
+internal fun JavaValueParameter.toFirValueParameters(session: FirSession): FirValueParameter {
+    return FirJavaValueParameter(
+        session, name ?: Name.special("<anonymous Java parameter>"),
+        returnTypeRef = type.toFirJavaTypeRef(session),
+        isVararg = isVararg
+    ).apply {
+        addAnnotationsFrom(this@toFirValueParameters)
+    }
+}
+
 internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter: FirTypeParameter?): ConeKotlinTypeProjection {
     return when (this) {
         null -> ConeStarProjection

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.fir.java.declarations
+
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
+import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl.Companion.NAME
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+
+class FirJavaConstructor(
+    session: FirSession,
+    symbol: FirFunctionSymbol,
+    visibility: Visibility,
+    delegatedSelfTypeRef: FirTypeRef
+) : FirAbstractCallableMember(
+    session, psi = null, symbol = symbol, name = NAME, visibility = visibility, modality = Modality.FINAL,
+    isExpect = false, isActual = false, isOverride = false, receiverTypeRef = null, returnTypeRef = delegatedSelfTypeRef
+), FirConstructor {
+    override val delegatedConstructor: FirDelegatedConstructorCall?
+        get() = null
+
+    override val body: FirBlock?
+        get() = null
+
+    override val valueParameters = mutableListOf<FirValueParameter>()
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
@@ -102,7 +103,9 @@ class JavaClassEnhancementScope(
         original: ConeFunctionSymbol,
         name: Name
     ): FirFunctionSymbol {
-        val firMethod = (original as FirFunctionSymbol).fir as? FirJavaMethod ?: return original
+        val firMethod = (original as FirFunctionSymbol).fir as? FirFunction
+
+        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor || firMethod !is FirCallableMember) return original
 
         val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firMethod.annotations)
 
@@ -117,8 +120,14 @@ class JavaClassEnhancementScope(
             }
         }
 
-        val newReceiverTypeRef = if (firMethod.receiverTypeRef != null) enhanceReceiverType(firMethod, memberContext) else null
+        val newReceiverTypeRef = if (firMethod is FirJavaMethod && firMethod.receiverTypeRef != null) {
-        val newReturnTypeRef = enhanceReturnType(firMethod, memberContext, predefinedEnhancementInfo)
+            enhanceReceiverType(firMethod, memberContext)
+        } else null
+        val newReturnTypeRef = if (firMethod is FirJavaConstructor) {
+            firMethod.returnTypeRef
+        } else {
+            enhanceReturnType(firMethod, memberContext, predefinedEnhancementInfo)
+        }
 
         val newValueParameterTypeRefs = mutableListOf<FirResolvedTypeRef>()
 
@@ -134,7 +143,7 @@ class JavaClassEnhancementScope(
                 session, null, symbol, name,
                 newReceiverTypeRef, newReturnTypeRef
             ).apply {
-                status = firMethod.status
+                status = firMethod.status as FirDeclarationStatusImpl
                 annotations += firMethod.annotations
                 valueParameters += firMethod.valueParameters.zip(newValueParameterTypeRefs) { valueParameter, newTypeRef ->
                     with(valueParameter) {
@@ -152,8 +161,12 @@ class JavaClassEnhancementScope(
         return symbol
     }
 
-    private fun FirJavaMethod.computeJvmDescriptor(): String = buildString {
+    private fun FirFunction.computeJvmDescriptor(): String = buildString {
-        append(name.asString()) // TODO: Java constructors
+        if (this@computeJvmDescriptor is FirJavaMethod) {
+            append(name.asString())
+        } else {
+            append("<init>")
+        }
 
         append("(")
         for (parameter in valueParameters) {
@@ -161,7 +174,7 @@ class JavaClassEnhancementScope(
         }
         append(")")
 
-        if ((returnTypeRef as FirJavaTypeRef).isVoid()) {
+        if (this@computeJvmDescriptor !is FirJavaMethod || (returnTypeRef as FirJavaTypeRef).isVoid()) {
             append("V")
         } else {
             // TODO: appendErasedType(returnTypeRef)
@@ -189,7 +202,7 @@ class JavaClassEnhancementScope(
     }
 
     private fun enhanceValueParameterType(
-        ownerFunction: FirJavaMethod,
+        ownerFunction: FirCallableMember,
         memberContext: FirJavaEnhancementContext,
         predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?,
         ownerParameter: FirJavaValueParameter,

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.createSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
@@ -187,6 +188,15 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                         for (declaration in javaClass.declarations) {
                             if (declaration in renderedDeclarations) continue
                             when (declaration) {
+                                is FirJavaConstructor -> enhancementScope.processFunctionsByName(javaClass.name) { symbol ->
+                                    val enhanced = (symbol as? FirFunctionSymbol)?.fir
+                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                        enhanced.accept(renderer, null)
+                                        renderer.newLine()
+                                        renderedDeclarations += enhanced
+                                    }
+                                    ProcessorAction.NEXT
+                                }
                                 is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol ->
                                     val enhanced = (symbol as? FirFunctionSymbol)?.fir
                                     if (enhanced != null && enhanced !in renderedDeclarations) {

compiler/testData/loadJava/compiledJava/MyException.fir.txt

@@ -1,2 +1,4 @@
 public open class MyException : R|java/lang/Object| {
+    public final function MyException(message: R|ft<kotlin/String, kotlin/String?>|!, cause: R|ft<kotlin/Throwable, kotlin/Throwable?>|!): R|test/MyException|
+
 }

compiler/testData/loadJava/compiledJava/PackageLocalVisibility.fir.txt

@@ -9,4 +9,6 @@ public open class JFrame : R|awt/Frame| {
         protected/*protected and package*/ get(): R|ft<kotlin/String, kotlin/String?>|!
         protected/*protected and package*/ set(value: R|ft<kotlin/String, kotlin/String?>|!): kotlin/Unit
 
+    public final function JFrame(): R|test/JFrame|
+
 }

compiler/testData/loadJava/compiledJava/PrivateMembers.fir.txt

@@ -5,4 +5,6 @@ public open class PrivateMembers : R|java/lang/Object| {
 
     private open operator function method(): R|kotlin/Unit|
 
+    private final function PrivateMembers(): R|test/PrivateMembers|
+
 }

compiler/testData/loadJava/compiledJava/Simple.fir.txt

@@ -1,2 +1,4 @@
 public final class Simple : R|java/lang/Object| {
+    public final function Simple(): R|test/Simple|
+
 }

compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.fir.txt

@@ -1,2 +1,4 @@
 public open class AnnotatedConstructor : R|java/lang/Object| {
+    @R|test/AnnotatedConstructor.Anno|(String(constructor)) public final function AnnotatedConstructor(): R|test/AnnotatedConstructor|
+
 }

compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt

@@ -1,2 +1,6 @@
 public final enum class EnumConstructorParameter : R|java/lang/Enum<test/EnumConstructorParameter>| {
+    private final function EnumConstructorParameter(@R|test/EnumConstructorParameter.Anno|(String(string)) s: R|ft<kotlin/String, kotlin/String?>|!): R|test/EnumConstructorParameter|
+
+    private final function EnumConstructorParameter(x: R|kotlin/Int|): R|test/EnumConstructorParameter|
+
 }

compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt

@@ -1,2 +1,4 @@
 public open class ConstructorGenericDeep : R|java/lang/Object| {
+    public final function ConstructorGenericDeep(cl: R|ft<java/lang/Class<ft<P, P?>>, java/lang/Class<ft<P, P?>>?>|!): R|test/ConstructorGenericDeep|
+
 }

compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt

@@ -1,2 +1,4 @@
 public open class ConstructorGenericSimple : R|java/lang/Object| {
+    public final function ConstructorGenericSimple(p: R|ft<P, P?>|!): R|test/ConstructorGenericSimple|
+
 }

compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt

@@ -1,2 +1,4 @@
 public open class ConstructorGenericUpperBound : R|java/lang/Object| {
+    public final function ConstructorGenericUpperBound(p: R|ft<P, P?>|!): R|test/ConstructorGenericUpperBound|
+
 }

compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt

@@ -4,4 +4,6 @@ public final enum class EnumMembers : R|java/lang/Enum<test/EnumMembers>| {
 
     public open operator function first(): R|kotlin/Boolean|
 
+    private final function EnumMembers(isFirst: R|kotlin/Boolean|): R|test/EnumMembers|
+
 }

compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt

@@ -1,2 +1,4 @@
 <T> public open class ConstructorWithNewTypeParams : R|java/lang/Object| {
+    public final function ConstructorWithNewTypeParams(first: R|ft<U, U?>|!): R|test/ConstructorWithNewTypeParams|
+
 }

compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt

@@ -1,2 +1,4 @@
 <T> public open class ConstructorWithParentTypeParams : R|java/lang/Object| {
+    public final function ConstructorWithParentTypeParams(first: R|ft<T, T?>|!): R|test/ConstructorWithParentTypeParams|
+
 }

compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithSeveralParams.fir.txt

@@ -1,2 +1,4 @@
 public open class ConstructorWithSeveralParams : R|java/lang/Object| {
+    public final function ConstructorWithSeveralParams(integer: R|ft<kotlin/Int, kotlin/Int?>|!, intBasic: R|kotlin/Int|, collection: R|ft<java/util/ArrayList<ft<kotlin/String, kotlin/String?>>, java/util/ArrayList<ft<kotlin/String, kotlin/String?>>?>|!): R|test/ConstructorWithSeveralParams|
+
 }

compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithoutParams.fir.txt

@@ -1,2 +1,4 @@
 public open class ConstructorWithoutParams : R|java/lang/Object| {
+    public final function ConstructorWithoutParams(): R|test/ConstructorWithoutParams|
+
 }

compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.fir.txt

@@ -1,2 +1,4 @@
 public open class Constructor : R|java/lang/Object| {
+    public final function Constructor(r: R|ft<java/lang/Runnable, java/lang/Runnable?>|!): R|test/Constructor|
+
 }

compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.fir.txt

@@ -1,2 +1,4 @@
 public open class ConstructorWithAnnotations : R|java/lang/Object| {
+    public final function ConstructorWithAnnotations(r: R|ft<java/lang/Runnable, java/lang/Runnable?>|!, @R|org/jetbrains/annotations/NotNull|() s: R|ft<kotlin/String, kotlin/String>|): R|test/ConstructorWithAnnotations|
+
 }