Refactoring: move common parts about SAMs to frontend module

2019-11-18 13:49:14 +03:00
parent fc32e8b017
commit c93c82236c
14 changed files with 136 additions and 158 deletions
@@ -0,0 +1,18 @@
+/*
+ * 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.load.java.sam
+
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
+import org.jetbrains.kotlin.resolve.SamConversionResolver
+import org.jetbrains.kotlin.types.SimpleType
+
+object JavaBasedSamConversionResolver : SamConversionResolver {
+    override fun resolveFunctionTypeIfSamInterface(classDescriptor: ClassDescriptor): SimpleType? {
+        if (classDescriptor !is JavaClassDescriptor) return null
+        return classDescriptor.defaultFunctionTypeForSamInterface
+    }
+}
@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.load.java.sam
-
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
-import org.jetbrains.kotlin.resolve.SamConversionResolver
-import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.types.SimpleType
-
-class SamConversionResolverImpl(
-        storageManager: StorageManager,
-        private val samWithReceiverResolvers: Iterable<SamWithReceiverResolver>
-): SamConversionResolver {
-    private val functionTypesForSamInterfaces = storageManager.createCacheWithNullableValues<ClassDescriptor, SimpleType>()
-
-    override fun resolveFunctionTypeIfSamInterface(classDescriptor: ClassDescriptor): SimpleType? {
-        return functionTypesForSamInterfaces.computeIfAbsent(classDescriptor) {
-            val abstractMethod = SingleAbstractMethodUtils.getSingleAbstractMethodOrNull(classDescriptor) ?: return@computeIfAbsent null
-            val shouldConvertFirstParameterToDescriptor = samWithReceiverResolvers.any { it.shouldConvertFirstSamParameterToReceiver(abstractMethod) }
-            SingleAbstractMethodUtils.getFunctionTypeForAbstractMethod(abstractMethod, shouldConvertFirstParameterToDescriptor)
-        }
-    }
-}
-
-object JavaBasedSamConversionResolver : SamConversionResolver {
-    override fun resolveFunctionTypeIfSamInterface(classDescriptor: ClassDescriptor): SimpleType? {
-        if (classDescriptor !is JavaClassDescriptor) return null
-        return classDescriptor.defaultFunctionTypeForSamInterface
-    }
-}
@@ -1,23 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.load.java.sam
-
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-
-interface SamWithReceiverResolver {
-    fun shouldConvertFirstSamParameterToReceiver(function: FunctionDescriptor): Boolean
-}
@@ -18,21 +18,18 @@ package org.jetbrains.kotlin.load.java.sam;

 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.FunctionTypesKt;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl;
-import org.jetbrains.kotlin.resolve.SamConversionResolver;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassConstructorDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor;
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaClassDescriptor;
+import org.jetbrains.kotlin.load.kotlin.sam.SamConversionResolverImplKt;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.name.SpecialNames;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
+import org.jetbrains.kotlin.resolve.SamConversionResolver;
 import org.jetbrains.kotlin.resolve.jvm.JavaResolverUtils;
 import org.jetbrains.kotlin.types.*;

@@ -47,17 +44,6 @@ public class SingleAbstractMethodUtils {
    private SingleAbstractMethodUtils() {
    }

-    @NotNull
-    public static List<CallableMemberDescriptor> getAbstractMembers(@NotNull ClassDescriptor classDescriptor) {
-        List<CallableMemberDescriptor> abstractMembers = new ArrayList<>();
-        for (DeclarationDescriptor member : DescriptorUtils.getAllDescriptors(classDescriptor.getUnsubstitutedMemberScope())) {
-            if (member instanceof CallableMemberDescriptor && ((CallableMemberDescriptor) member).getModality() == Modality.ABSTRACT) {
-                abstractMembers.add((CallableMemberDescriptor) member);
-            }
-        }
-        return abstractMembers;
-    }
-
    @Nullable
    public static KotlinType getFunctionTypeForSamType(@NotNull KotlinType samType, @NotNull SamConversionResolver samResolver) {
        UnwrappedType unwrappedType = samType.unwrap();
@@ -103,75 +89,13 @@ public class SingleAbstractMethodUtils {
        return null;
    }

-    @NotNull
-    public static SimpleType getFunctionTypeForAbstractMethod(
-            @NotNull FunctionDescriptor function,
-            boolean shouldConvertFirstParameterToDescriptor
-    ) {
-        KotlinType returnType = function.getReturnType();
-        assert returnType != null : "function is not initialized: " + function;
-        List<ValueParameterDescriptor> valueParameters = function.getValueParameters();
-        List<KotlinType> parameterTypes = new ArrayList<>(valueParameters.size());
-        List<Name> parameterNames = new ArrayList<>(valueParameters.size());
-
-        int startIndex = 0;
-        KotlinType receiverType = null;
-
-        if (shouldConvertFirstParameterToDescriptor && !function.getValueParameters().isEmpty()) {
-            receiverType = valueParameters.get(0).getType();
-            startIndex = 1;
-        }
-
-        for (int i = startIndex; i < valueParameters.size(); ++i) {
-            ValueParameterDescriptor parameter = valueParameters.get(i);
-            parameterTypes.add(parameter.getType());
-            parameterNames.add(function.hasSynthesizedParameterNames() ? SpecialNames.NO_NAME_PROVIDED : parameter.getName());
-        }
-
-        return FunctionTypesKt.createFunctionType(
-                DescriptorUtilsKt.getBuiltIns(function), Annotations.Companion.getEMPTY(),
-                receiverType, parameterTypes, parameterNames, returnType, function.isSuspend()
-        );
-    }
-
-    @Nullable
-    public static FunctionDescriptor getSingleAbstractMethodOrNull(@NotNull ClassDescriptor klass) {
-        // NB: this check MUST BE at start. Please do not touch until following to-do is resolved
-        // Otherwise android data binding can cause resolve re-entrance
-        // For details see KT-18687, KT-16149
-        // TODO: prevent resolve re-entrance on architecture level, or (alternatively) ask data binding owners not to do it
-        if (DescriptorUtilsKt.getFqNameSafe(klass).asString().endsWith(".databinding.DataBindingComponent")) {
-            return null;
-        }
-
-        if (klass instanceof JavaClassDescriptor) {
-            if (((JavaClassDescriptor) klass).isDefinitelyNotSamInterface()) {
-                return null;
-            }
-        } else if (!klass.isFun()) {
-            return null;
-        }
-
-        List<CallableMemberDescriptor> abstractMembers = getAbstractMembers(klass);
-        if (abstractMembers.size() == 1) {
-            CallableMemberDescriptor member = abstractMembers.get(0);
-            if (member instanceof SimpleFunctionDescriptor) {
-                return member.getTypeParameters().isEmpty()
-                       ? (FunctionDescriptor) member
-                       : null;
-            }
-        }
-
-        return null;
-    }
-
    @NotNull
    public static SamConstructorDescriptor createSamConstructorFunction(
            @NotNull DeclarationDescriptor owner,
            @NotNull ClassDescriptor samInterface,
            @NotNull SamConversionResolver samResolver
    ) {
-        assert getSingleAbstractMethodOrNull(samInterface) != null : samInterface;
+        assert SamConversionResolverImplKt.getSingleAbstractMethodOrNull(samInterface) != null : samInterface;

        SamConstructorDescriptorImpl result = new SamConstructorDescriptorImpl(owner, samInterface);

@@ -235,9 +159,7 @@ public class SingleAbstractMethodUtils {

    public static boolean isSamClassDescriptor(@NotNull ClassDescriptor descriptor) {
        if (descriptor.isFun()) return true;
-        if (descriptor instanceof LazyJavaClassDescriptor &&
-            ((LazyJavaClassDescriptor) descriptor).getDefaultFunctionTypeForSamInterface() != null
-        ) return true;
+        if (descriptor instanceof LazyJavaClassDescriptor && descriptor.getDefaultFunctionTypeForSamInterface() != null) return true;

        return false;
    }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.resolve.SamConversionResolver
 import org.jetbrains.kotlin.load.java.sam.JvmSamConversionTransformer
-import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
+import org.jetbrains.kotlin.load.kotlin.sam.SamConversionResolverImpl
 import org.jetbrains.kotlin.resolve.PlatformConfiguratorBase
 import org.jetbrains.kotlin.resolve.checkers.BigFunctionTypeAvailabilityChecker
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker