Extract SAM constructor resolution logic to a component

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

@@ -17,15 +17,11 @@
 package org.jetbrains.jet.lang.resolve.java.descriptor;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 
 public class SamConstructorDescriptor extends SimpleFunctionDescriptorImpl {
-
-    public SamConstructorDescriptor(
-            @NotNull ClassOrPackageFragmentDescriptor containingDeclaration,
-            @NotNull JavaClassDescriptor samInterface
-    ) {
+    public SamConstructorDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JavaClassDescriptor samInterface) {
         super(containingDeclaration, null, samInterface.getAnnotations(), samInterface.getName(),
               Kind.SYNTHESIZED, samInterface.getSource());
     }

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

@@ -43,6 +43,7 @@ public class LazyJavaPackageFragmentProvider(
             outerContext.methodSignatureChecker,
             outerContext.javaResolverCache,
             outerContext.javaPropertyInitializerEvaluator,
+            outerContext.samConversionResolver,
             outerContext.sourceElementFactory,
             outerContext.moduleClassResolver
     )

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

@@ -21,11 +21,7 @@ import org.jetbrains.jet.lang.resolve.java.lazy.types.LazyJavaTypeResolver
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinder
-import org.jetbrains.jet.lang.resolve.java.resolver.ExternalAnnotationResolver
-import org.jetbrains.jet.lang.resolve.java.resolver.ExternalSignatureResolver
-import org.jetbrains.jet.lang.resolve.java.resolver.MethodSignatureChecker
-import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaResolverCache
+import org.jetbrains.jet.lang.resolve.java.resolver.*
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPropertyInitializerEvaluator
@@ -42,6 +38,7 @@ open class GlobalJavaResolverContext(
         val methodSignatureChecker: MethodSignatureChecker,
         val javaResolverCache: JavaResolverCache,
         val javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
+        val samConversionResolver: SamConversionResolver,
         val sourceElementFactory: JavaSourceElementFactory,
         val moduleClassResolver: ModuleClassResolver
 )
@@ -59,12 +56,13 @@ open class LazyJavaResolverContext(
         methodSignatureChecker: MethodSignatureChecker,
         javaResolverCache: JavaResolverCache,
         javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
+        samConversionResolver: SamConversionResolver,
         sourceElementFactory: JavaSourceElementFactory,
         moduleClassResolver: ModuleClassResolver
 ) : GlobalJavaResolverContext(storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver,
                               externalAnnotationResolver, externalSignatureResolver,
                               errorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator,
-                              sourceElementFactory, moduleClassResolver)
+                              samConversionResolver, sourceElementFactory, moduleClassResolver)
 
 fun LazyJavaResolverContext.withTypes(
         typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
@@ -81,10 +79,12 @@ fun LazyJavaResolverContext.withTypes(
         methodSignatureChecker,
         javaResolverCache,
         javaPropertyInitializerEvaluator,
+        samConversionResolver,
         sourceElementFactory,
         moduleClassResolver,
         LazyJavaTypeResolver(this, typeParameterResolver),
-        typeParameterResolver)
+        typeParameterResolver
+)
 
 class LazyJavaResolverContextWithTypes(
         packageFragmentProvider: LazyJavaPackageFragmentProvider,
@@ -99,14 +99,15 @@ class LazyJavaResolverContextWithTypes(
         methodSignatureChecker: MethodSignatureChecker,
         javaResolverCache: JavaResolverCache,
         javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
+        samConversionResolver: SamConversionResolver,
         sourceElementFactory: JavaSourceElementFactory,
         moduleClassResolver: ModuleClassResolver,
         val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
-) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder,
-                            kotlinClassFinder, deserializedDescriptorResolver,
-                            externalAnnotationResolver, externalSignatureResolver, errorReporter, methodSignatureChecker,
-                            javaResolverCache, javaPropertyInitializerEvaluator, sourceElementFactory, moduleClassResolver)
+) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder, kotlinClassFinder,
+                            deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, errorReporter,
+                            methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver,
+                            sourceElementFactory, moduleClassResolver)
 
 fun LazyJavaResolverContextWithTypes.child(
         containingDeclaration: DeclarationDescriptor,

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

@@ -67,6 +67,7 @@ public abstract class LazyJavaMemberScope(
 
     protected abstract fun computeMemberIndex(): MemberIndex
 
+    // Fake overrides, SAM constructors/adapters, values()/valueOf(), etc.
     protected abstract fun computeNonDeclaredFunctions(result: MutableCollection<SimpleFunctionDescriptor>, name: Name)
 
     protected abstract fun getDispatchReceiverParameter(): ReceiverParameterDescriptor?

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

@@ -27,13 +27,12 @@ import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.resolve.java.lazy.findClassInJava
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaMemberScope.MethodSignatureData
-import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.lang.resolve.DescriptorFactory.*
+import org.jetbrains.jet.utils.addIfNotNull
 
 public abstract class LazyJavaStaticScope(
         c: LazyJavaResolverContext,
@@ -60,15 +59,6 @@ public abstract class LazyJavaStaticScope(
     override fun computeNonDeclaredProperties(name: Name, result: MutableCollection<PropertyDescriptor>) {
         //no undeclared properties
     }
-
-    override fun getContainingDeclaration() = super.getContainingDeclaration() as ClassOrPackageFragmentDescriptor
-
-    fun ClassifierDescriptor.createSamConstructor(): SamConstructorDescriptor? {
-        if (this is LazyJavaClassDescriptor && this.getFunctionTypeForSamInterface() != null) {
-            return SingleAbstractMethodUtils.createSamConstructorFunction(this@LazyJavaStaticScope.getContainingDeclaration(), this)
-        }
-        return null
-    }
 }
 
 public class LazyPackageFragmentScopeForJavaPackage(
@@ -137,10 +127,7 @@ public class LazyPackageFragmentScopeForJavaPackage(
     )
 
     override fun computeNonDeclaredFunctions(result: MutableCollection<SimpleFunctionDescriptor>, name: Name) {
-        val samConstructor = getClassifier(name)?.createSamConstructor()
-        if (samConstructor != null) {
-            result.add(samConstructor)
-        }
+        result.addIfNotNull(c.samConversionResolver.resolveSamConstructor(name, this))
     }
 
     override fun getSubPackages() = _subPackages()
@@ -189,11 +176,8 @@ public class LazyJavaStaticClassScope(
     override fun getSubPackages(): Collection<FqName> = listOf()
 
     override fun computeNonDeclaredFunctions(result: MutableCollection<SimpleFunctionDescriptor>, name: Name) {
-        //NOTE: assuming that all sam constructors are created for interfaces which are static and should be placed in this scope
-        val samConstructor = getContainingDeclaration().getUnsubstitutedInnerClassesScope().getClassifier(name)?.createSamConstructor()
-        if (samConstructor != null) {
-            result.add(samConstructor)
-        }
+        val nestedClassesScope = getContainingDeclaration().getUnsubstitutedInnerClassesScope()
+        result.addIfNotNull(c.samConversionResolver.resolveSamConstructor(name, nestedClassesScope))
     }
 
     override fun getContainingDeclaration() = super.getContainingDeclaration() as LazyJavaClassDescriptor

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2014 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.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
+
+public trait SamConversionResolver {
+    public fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor?
+}

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

@@ -141,7 +141,7 @@ public class SingleAbstractMethodUtils {
 
     @NotNull
     public static SamConstructorDescriptor createSamConstructorFunction(
-            @NotNull ClassOrPackageFragmentDescriptor owner,
+            @NotNull DeclarationDescriptor owner,
             @NotNull JavaClassDescriptor samInterface
     ) {
         assert isSamInterface(samInterface) : samInterface;