Move SAM adapter resolution logic to SamConversionResolver

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/SamConversionResolverImpl.kt

@@ -21,6 +21,9 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaClassDescriptor
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaConstructorDescriptor
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor
 
 public object SamConversionResolverImpl : SamConversionResolver {
     override fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor? {
@@ -28,4 +31,14 @@ public object SamConversionResolverImpl : SamConversionResolver {
         if (classifier.getFunctionTypeForSamInterface() == null) return null
         return SingleAbstractMethodUtils.createSamConstructorFunction(scope.getContainingDeclaration(), classifier)
     }
+
+    suppress("UNCHECKED_CAST")
+    override fun <D : FunctionDescriptor> resolveSamAdapter(original: D): D? {
+        return when {
+            !SingleAbstractMethodUtils.isSamAdapterNecessary(original) -> null
+            original is JavaConstructorDescriptor -> SingleAbstractMethodUtils.createSamAdapterConstructor(original) as D
+            original is JavaMethodDescriptor -> SingleAbstractMethodUtils.createSamAdapterFunction(original) as D
+            else -> null
+        }
+    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt

@@ -90,7 +90,7 @@ class LazyJavaClassDescriptor(
     override fun getClassObjectDescriptor(): ClassDescriptor? = null
     override fun getClassObjectType(): JetType? = getClassObjectDescriptor()?.let { d -> d.getDefaultType() }
 
-    override fun getConstructors() = _scopeForMemberLookup._constructors()
+    override fun getConstructors() = _scopeForMemberLookup.constructors()
 
     private val _annotations = c.storageManager.createLazyValue { c.resolveAnnotations(jClass) }
     override fun getAnnotations() = _annotations()

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt

@@ -31,7 +31,6 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import org.jetbrains.jet.lang.descriptors.impl.EnumEntrySyntheticClassDescriptor
 import org.jetbrains.jet.lang.types.TypeUtils
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations
-import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
 import org.jetbrains.jet.lang.resolve.java.JavaVisibilities
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaConstructorDescriptor
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
@@ -51,19 +50,15 @@ public class LazyJavaClassMemberScope(
         }
     }
 
-    internal val _constructors = c.storageManager.createLazyValue {
+    internal val constructors = c.storageManager.createLazyValue {
-        jClass.getConstructors().flatMap { ctor ->
+        val constructors = jClass.getConstructors()
-            val constructor = resolveConstructor(ctor, getContainingDeclaration())
+        val result = ArrayList<JavaConstructorDescriptor>(constructors.size)
-            val samAdapter = resolveSamAdapter(constructor)
+        for (constructor in constructors) {
-            if (samAdapter != null) {
+            val descriptor = resolveConstructor(constructor)
-                samAdapter.setReturnType(containingDeclaration.getDefaultType())
+            result.add(descriptor)
-                listOf(constructor, samAdapter)
+            result.addIfNotNull(c.samConversionResolver.resolveSamAdapter(descriptor))
-            }
-            else
-                listOf(constructor)
-        } ifEmpty {
-            emptyOrSingletonList(createDefaultConstructor())
         }
+        result ifEmpty { emptyOrSingletonList(createDefaultConstructor()) }
     }
 
     override fun computeNonDeclaredFunctions(result: MutableCollection<SimpleFunctionDescriptor>, name: Name) {
@@ -105,13 +100,9 @@ public class LazyJavaClassMemberScope(
         return MethodSignatureData(effectiveSignature, superFunctions, propagated.getErrors() + effectiveSignature.getErrors())
     }
 
-    private fun resolveSamAdapter(original: JavaConstructorDescriptor): JavaConstructorDescriptor? {
+    private fun resolveConstructor(constructor: JavaConstructor): JavaConstructorDescriptor {
-        return if (SingleAbstractMethodUtils.isSamAdapterNecessary(original))
+        val classDescriptor = getContainingDeclaration()
-                   SingleAbstractMethodUtils.createSamAdapterConstructor(original) as JavaConstructorDescriptor
-               else null
-    }
 
-    private fun resolveConstructor(constructor: JavaConstructor, classDescriptor: ClassDescriptor): JavaConstructorDescriptor {
         val constructorDescriptor = JavaConstructorDescriptor.createJavaConstructor(
                 classDescriptor, Annotations.EMPTY, /* isPrimary = */ false, c.sourceElementFactory.source(constructor)
         )

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt

@@ -41,7 +41,6 @@ import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptor
 import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl
 import org.jetbrains.jet.lang.resolve.java.resolver.ExternalSignatureResolver
-import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
 import org.jetbrains.jet.utils.*
 import org.jetbrains.jet.lang.resolve.java.PLATFORM_TYPES
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations
@@ -72,33 +71,25 @@ public abstract class LazyJavaMemberScope(
 
     protected abstract fun getDispatchReceiverParameter(): ReceiverParameterDescriptor?
 
-    private val _functions = c.storageManager.createMemoizedFunction {
+    private val functions = c.storageManager.createMemoizedFunction {(name: Name): Collection<FunctionDescriptor> ->
-        (name: Name): Collection<FunctionDescriptor> ->
+        val result = LinkedHashSet<SimpleFunctionDescriptor>()
-        val methods = memberIndex().findMethodsByName(name)
-        val functions = LinkedHashSet<SimpleFunctionDescriptor>(
-                methods.stream()
-                        .flatMap {
-                            m ->
-                            val function = resolveMethodToFunctionDescriptor(m, true)
-                            val samAdapter = resolveSamAdapter(function)
-                            if (samAdapter != null)
-                                listOf(function, samAdapter).stream()
-                            else
-                                listOf(function).stream()
-                        }
-                        .toList()
-        )
 
-        computeNonDeclaredFunctions(functions, name)
+        for (method in memberIndex().findMethodsByName(name)) {
+            val descriptor = resolveMethodToFunctionDescriptor(method, true)
+            result.add(descriptor)
+            result.addIfNotNull(c.samConversionResolver.resolveSamAdapter(descriptor))
+        }
+
+        computeNonDeclaredFunctions(result, name)
 
         // Make sure that lazy things are computed before we release the lock
-        for (f in functions) {
+        for (f in result) {
             for (p in f.getValueParameters()) {
                 p.hasDefaultValue()
             }
         }
 
-        functions.toReadOnlyList()
+        result.toReadOnlyList()
     }
 
     data class MethodSignatureData(
@@ -213,18 +204,12 @@ public abstract class LazyJavaMemberScope(
         return ResolvedValueParameters(descriptors, synthesizedNames)
     }
 
-    private fun resolveSamAdapter(original: JavaMethodDescriptor): JavaMethodDescriptor? {
+    override fun getFunctions(name: Name) = functions(name)
-        return if (SingleAbstractMethodUtils.isSamAdapterNecessary(original))
-                    SingleAbstractMethodUtils.createSamAdapterFunction(original) as JavaMethodDescriptor
-               else null
-    }
-
-    override fun getFunctions(name: Name) = _functions(name)
     protected open fun getAllFunctionNames(): Collection<Name> = memberIndex().getAllMethodNames()
 
     protected abstract fun computeNonDeclaredProperties(name: Name, result: MutableCollection<PropertyDescriptor>)
 
-    val _properties = c.storageManager.createMemoizedFunction {
+    private val properties = c.storageManager.createMemoizedFunction {
         (name: Name) ->
         val properties = ArrayList<PropertyDescriptor>()
 
@@ -291,7 +276,7 @@ public abstract class LazyJavaMemberScope(
         return propertyType
     }
 
-    override fun getProperties(name: Name): Collection<VariableDescriptor> = _properties(name)
+    override fun getProperties(name: Name): Collection<VariableDescriptor> = properties(name)
     protected open fun getAllPropertyNames(): Collection<Name> = memberIndex().getAllFieldNames()
 
     override fun getLocalVariable(name: Name): VariableDescriptor? = null

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/SamConversionResolver.kt

@@ -19,7 +19,10 @@ package org.jetbrains.jet.lang.resolve.java.resolver
 import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 
 public trait SamConversionResolver {
     public fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor?
+
+    public fun <D : FunctionDescriptor> resolveSamAdapter(original: D): D?
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java

@@ -222,6 +222,7 @@ public class SingleAbstractMethodUtils {
                     @Nullable JetType returnType
             ) {
                 result.initialize(typeParameters, valueParameters, original.getVisibility());
+                result.setReturnType(result.getContainingDeclaration().getDefaultType());
             }
         });
     }