SAM-adapters are sorted as non-extensions in completion and with correct boldness + no parameter names when from compiled

2015-08-13 21:10:26 +03:00
parent 13fc12bbae
commit b6cf39981f
11 changed files with 144 additions and 54 deletions
@@ -32,7 +32,7 @@ public class SamCodegenUtil {
        }

        if (original instanceof SamAdapterExtensionFunctionDescriptor) {
-            return ((SamAdapterExtensionFunctionDescriptor) original).getOriginalFunction();
+            return ((SamAdapterExtensionFunctionDescriptor) original).getSourceFunction();
        }

        if (original.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
@@ -29,15 +29,14 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.types.DescriptorSubstitutor
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.TypeSubstitution
-import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.*
 import java.util.ArrayList
+import java.util.HashMap
 import java.util.LinkedHashSet
+import kotlin.properties.Delegates

 interface SamAdapterExtensionFunctionDescriptor : FunctionDescriptor {
-    val originalFunction: FunctionDescriptor
+    val sourceFunction: FunctionDescriptor
 }

 class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by JetScope.Empty {
@@ -52,7 +51,7 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet
        if (function.returnType == null) return null
        //TODO: it's a temporary hack while original returns a function with platform types
        val enhancedFunction = function.enhanceSignature()
-        return MyFunctionDescriptor(enhancedFunction)
+        return MyFunctionDescriptor.create(enhancedFunction)
    }

    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
@@ -85,38 +84,101 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet
    }

    private class MyFunctionDescriptor(
-            override val originalFunction: FunctionDescriptor
-    ) : SamAdapterExtensionFunctionDescriptor, SimpleFunctionDescriptorImpl(
-            DescriptorUtils.getContainingModule(originalFunction),
-            null,
-            Annotations.EMPTY, //TODO
-            originalFunction.name,
-            CallableMemberDescriptor.Kind.SYNTHESIZED,
-            originalFunction.source
-    ) {
-        init {
-            val typeParamsSum = (originalFunction.typeParameters).toArrayList()
-            val ownerClass = originalFunction.containingDeclaration as ClassDescriptor
-            //TODO: should we go up parents for getters/setters too?
-            for (parent in ownerClass.parentsWithSelf) {
-                if (parent !is ClassDescriptor) break
-                typeParamsSum += parent.typeConstructor.parameters
+            containingDeclaration: DeclarationDescriptor,
+            original: SimpleFunctionDescriptor?,
+            annotations: Annotations,
+            name: Name,
+            kind: CallableMemberDescriptor.Kind,
+            source: SourceElement
+    ) : SamAdapterExtensionFunctionDescriptor, SimpleFunctionDescriptorImpl(containingDeclaration, original, annotations, name, kind, source) {
+
+        override var sourceFunction: FunctionDescriptor by Delegates.notNull()
+            private set
+
+        private var toSourceFunctionTypeParameters: Map<TypeParameterDescriptor, TypeParameterDescriptor>? = null
+
+        companion object {
+            fun create(sourceFunction: FunctionDescriptor): MyFunctionDescriptor {
+                val descriptor = MyFunctionDescriptor(DescriptorUtils.getContainingModule(sourceFunction),
+                                                      null,
+                                                      Annotations.EMPTY, //TODO
+                                                      sourceFunction.name,
+                                                      CallableMemberDescriptor.Kind.SYNTHESIZED,
+                                                      sourceFunction.source)
+                descriptor.sourceFunction = sourceFunction
+
+                val sourceTypeParams = (sourceFunction.typeParameters).toArrayList()
+                val ownerClass = sourceFunction.containingDeclaration as ClassDescriptor
+                //TODO: should we go up parents for getters/setters too?
+                //TODO: non-inner classes
+                for (parent in ownerClass.parentsWithSelf) {
+                    if (parent !is ClassDescriptor) break
+                    sourceTypeParams += parent.typeConstructor.parameters
+                }
+                //TODO: duplicated parameter names
+
+                val typeParameters = ArrayList<TypeParameterDescriptor>(sourceTypeParams.size())
+                val typeSubstitutor = DescriptorSubstitutor.substituteTypeParameters(sourceTypeParams, TypeSubstitution.EMPTY, descriptor, typeParameters)
+
+                descriptor.toSourceFunctionTypeParameters = typeParameters.zip(sourceTypeParams).toMap()
+
+                val returnType = typeSubstitutor.safeSubstitute(sourceFunction.returnType!!, Variance.INVARIANT)
+                val receiverType = typeSubstitutor.safeSubstitute(ownerClass.defaultType, Variance.INVARIANT)
+                val valueParameters = SingleAbstractMethodUtils.createValueParametersForSamAdapter(sourceFunction, descriptor, typeSubstitutor)
+
+                val visibility = syntheticExtensionVisibility(sourceFunction)
+
+                descriptor.initialize(receiverType, null, typeParameters, valueParameters, returnType, Modality.FINAL, visibility)
+
+                return descriptor
            }
-            //TODO: duplicated parameter names
-
-            val typeParameters = ArrayList<TypeParameterDescriptor>(typeParamsSum.size())
-            val typeSubstitutor = DescriptorSubstitutor.substituteTypeParameters(typeParamsSum, TypeSubstitution.EMPTY, this, typeParameters)
-
-            val returnType = typeSubstitutor.safeSubstitute(originalFunction.returnType!!, Variance.INVARIANT)
-            val receiverType = typeSubstitutor.safeSubstitute(ownerClass.defaultType, Variance.INVARIANT)
-            val valueParameters = SingleAbstractMethodUtils.createValueParametersForSamAdapter(originalFunction, this, typeSubstitutor)
-
-            val visibility = syntheticExtensionVisibility(originalFunction)
-
-            initialize(receiverType, null, typeParameters, valueParameters, returnType, Modality.FINAL, visibility)
        }

-        override fun hasStableParameterNames() = originalFunction.hasStableParameterNames()
-        override fun hasSynthesizedParameterNames() = originalFunction.hasSynthesizedParameterNames()
+        override fun hasStableParameterNames() = sourceFunction.hasStableParameterNames()
+        override fun hasSynthesizedParameterNames() = sourceFunction.hasSynthesizedParameterNames()
+
+        override fun createSubstitutedCopy(newOwner: DeclarationDescriptor, original: FunctionDescriptor?, kind: CallableMemberDescriptor.Kind): MyFunctionDescriptor {
+            return MyFunctionDescriptor(containingDeclaration, original as SimpleFunctionDescriptor?, annotations, name, kind, source).apply {
+                sourceFunction = this@MyFunctionDescriptor.sourceFunction
+            }
+        }
+
+        override fun doSubstitute(
+                originalSubstitutor: TypeSubstitutor,
+                newOwner: DeclarationDescriptor,
+                newModality: Modality,
+                newVisibility: Visibility,
+                original: FunctionDescriptor?,
+                copyOverrides: Boolean,
+                kind: CallableMemberDescriptor.Kind,
+                newValueParameterDescriptors: MutableList<ValueParameterDescriptor>,
+                newExtensionReceiverParameterType: JetType?,
+                newReturnType: JetType
+        ): FunctionDescriptor? {
+            val descriptor = super<SimpleFunctionDescriptorImpl>.doSubstitute(
+                    originalSubstitutor, newOwner, newModality, newVisibility, original,
+                    copyOverrides, kind, newValueParameterDescriptors, newExtensionReceiverParameterType, newReturnType)
+                as MyFunctionDescriptor? ?: return null
+
+            if (original == null) {
+                throw UnsupportedOperationException("doSubstitute with no original should not be called for synthetic extension")
+            }
+
+            original as MyFunctionDescriptor
+            assert(original.original == original, "original in doSubstitute should have no other original")
+
+            val substitutionMap = HashMap<TypeConstructor, TypeProjection>()
+            for (typeParameter in original.typeParameters) {
+                val typeProjection = originalSubstitutor.substitution[typeParameter.defaultType] ?: continue
+                val sourceTypeParameter = original.toSourceFunctionTypeParameters!![typeParameter]!!
+                substitutionMap[sourceTypeParameter.typeConstructor] = typeProjection
+
+            }
+
+            val sourceFunctionSubstitutor = TypeSubstitutor.create(substitutionMap)
+            descriptor.sourceFunction = original.sourceFunction.substitute(sourceFunctionSubstitutor)!!
+
+            return descriptor
+        }
    }
 }
@@ -255,8 +255,7 @@ public class LookupElementFactory(
        }

        if (descriptor is CallableDescriptor) {
-            val original = descriptor.original
-            val extensionReceiver = original.extensionReceiverParameter
+            val extensionReceiver = descriptor.original.extensionReceiverParameter
            when {
                descriptor is SyntheticJavaPropertyDescriptor -> {
                    var from = descriptor.getMethod.getName().asString() + "()"
@@ -265,7 +264,7 @@ public class LookupElementFactory(
                }

                // no need to show them as extensions
-                original is SamAdapterExtensionFunctionDescriptor -> {}
+                descriptor is SamAdapterExtensionFunctionDescriptor -> {}

                extensionReceiver != null -> {
                    val receiverPresentation = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(extensionReceiver.type)
@@ -336,6 +335,9 @@ public class LookupElementFactory(
        if (descriptor is SyntheticJavaPropertyDescriptor) {
            return callableWeight(descriptor.getMethod)
        }
+        if (descriptor is SamAdapterExtensionFunctionDescriptor) {
+            return callableWeight(descriptor.sourceFunction)
+        }

        val receiverParameter = descriptor.extensionReceiverParameter ?: descriptor.dispatchReceiverParameter
        if (receiverParameter != null) {
@@ -1,6 +0,0 @@
-import lib.JavaClass
-
-fun test() = JavaClass().<caret>
-
-// EXIST: { lookupString: "execute", itemText: "execute", tailText: "(Runnable!)", typeText: "Unit" }
-// EXIST: { lookupString: "execute", itemText: "execute", tailText: " {...} ((() -> Unit)!)", typeText: "Unit" }
@@ -1,5 +0,0 @@
-package lib;
-
-public class JavaClass {
-    public void execute(Runnable runnable) {}
-}
@@ -0,0 +1,8 @@
+import lib.JavaClass
+
+class KotlinClass : JavaClass()
+
+fun test() = KotlinClass().<caret>
+
+// EXIST: { lookupString: "execute", itemText: "execute", tailText: "(Runnable!, Int)", typeText: "Unit", attributes: "" }
+// EXIST: { lookupString: "execute", itemText: "execute", tailText: "((() -> Unit)!, Int)", typeText: "Unit", attributes: "" }
@@ -0,0 +1,8 @@
+import lib.*;
+
+fun foo(j: JavaInterface<String>) {
+    j.<caret>
+}
+
+// EXIST: { lookupString: "execute", itemText: "execute", tailText: "(Task<String!>!, K!)", typeText: "String!", attributes: "bold" }
+// EXIST: { lookupString: "execute", itemText: "execute", tailText: "(((String!) -> Unit)!, K!)", typeText: "String!", attributes: "bold" }
@@ -0,0 +1,5 @@
+package lib;
+
+public interface JavaInterface<T> {
+    <K> T execute(Task<T> task, K k);
+}
@@ -0,0 +1,5 @@
+package lib;
+
+public interface Task<T> {
+    void run(T t);
+}
@@ -0,0 +1,5 @@
+package lib;
+
+public class JavaClass {
+    public void execute(Runnable runnable, int x) {}
+}
@@ -47,9 +47,15 @@ public class JvmWithLibBasicCompletionTestGenerated extends AbstractJvmWithLibBa
        doTest(fileName);
    }

-    @TestMetadata("SAMAdapters.kt")
-    public void testSAMAdapters() throws Exception {
-        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/custom/SAMAdapters.kt");
+    @TestMetadata("SamAdapter.kt")
+    public void testSamAdapter() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/custom/SamAdapter.kt");
+        doTest(fileName);
+    }
+
+    @TestMetadata("SamAdapterAndGenerics.kt")
+    public void testSamAdapterAndGenerics() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/custom/SamAdapterAndGenerics.kt");
        doTest(fileName);
    }