Signature enhancement: most basic version implemented

2015-04-17 18:22:02 +03:00
parent 61da419c4a
commit 4248654f5f
1 changed files with 116 additions and 2 deletions
@@ -16,9 +16,123 @@

 package org.jetbrains.kotlin.load.java.components

+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver
+import org.jetbrains.kotlin.types.JetType

 fun <D : CallableMemberDescriptor> enhanceSignatures(platformSignatures: Collection<D>): Collection<D> {
-    // TODO: implement
-    return platformSignatures
+    return platformSignatures.map {
+        it.enhance()
+    }
+}
+
+fun <D : CallableMemberDescriptor> D.enhance(): D {
+    // TODO type parameters
+    // TODO use new type parameters while enhancing other types
+    // TODO Propagation into generic type arguments
+
+    val enhancedReceiverType =
+            if (getExtensionReceiverParameter() != null)
+                parts { it.getExtensionReceiverParameter()!!.toPart() }.enhance()
+            else null
+
+    val enhancedValueParameters = getValueParameters().map {
+        p -> parts { it.getValueParameters()[p.getIndex()]!!.toPart() }.enhance()
+    }
+
+    val enhancedReturnType = parts { it.getReturnType()!!.toReturnTypePart() }.enhance()
+
+    if (this is JavaMethodDescriptor) {
+        val enhancedFunction = JavaMethodDescriptor.createJavaMethod(
+                getContainingDeclaration()!!,
+                getAnnotations(),
+                getName(),
+                getSource()
+        )
+        enhancedFunction.initialize(
+                enhancedReceiverType,
+                getDispatchReceiverParameter(),
+                getTypeParameters(),
+                enhancedValueParameters,
+                enhancedReturnType,
+                getModality(),
+                getVisibility()
+        )
+        enhancedFunction.setHasStableParameterNames(hasStableParameterNames())
+        enhancedFunction.setHasSynthesizedParameterNames(hasSynthesizedParameterNames())
+
+        for (overridden in getOverriddenDescriptors()) {
+            enhancedFunction.addOverriddenDescriptor(overridden)
+        }
+
+        @suppress("UNCHECKED_CAST")
+        return enhancedFunction as D
+    }
+
+    return this
+}
+
+fun <T, P : SignaturePart<T>> SignatureParts<T, P>.enhance(): T {
+    val qualifiers = fromOverride.type.computeQualifiersForOverride(this.fromOverridden.map { it.type }, fromOverride.isCovariant)
+    return fromOverride.replaceType(fromOverride.type.enhance(qualifiers))
+}
+
+class SignatureParts<T, P: SignaturePart<T>>(
+        val fromOverride: P,
+        val fromOverridden: Collection<P>
+)
+
+interface SignaturePart<out T> {
+    val isCovariant: Boolean
+        get() = false
+
+    val type: JetType
+
+    fun replaceType(newType: JetType): T
+}
+
+fun ReceiverParameterDescriptor.toPart() = object : SignaturePart<JetType> {
+    override val type = getType()
+
+    override fun replaceType(newType: JetType) = newType
+}
+
+fun ValueParameterDescriptor.toPart() = object : SignaturePart<ValueParameterDescriptor> {
+    override val type = getType()
+
+    override fun replaceType(newType: JetType) = ValueParameterDescriptorImpl(
+            getContainingDeclaration(),
+            null,
+            getIndex(),
+            getAnnotations(),
+            getName(),
+            newType,
+            declaresDefaultValue(),
+            if (getVarargElementType() != null) newType.getArguments()[0].getType() else null,
+            getSource()
+    )
+}
+
+fun JetType.toReturnTypePart() = object : SignaturePart<JetType> {
+    override val type = this@toReturnTypePart
+
+    override val isCovariant: Boolean = true
+
+    override fun replaceType(newType: JetType) = newType
+}
+
+fun <D : CallableMemberDescriptor, T, P : SignaturePart<T>> D.parts(collector: (D) -> P): SignatureParts<T, P> {
+    return SignatureParts(
+            collector(this),
+            this.getOverriddenDescriptors().map {
+                @suppress("UNCHECKED_CAST")
+                collector(it as D)
+            }
+    )
 }