Extract SAM constructor resolution logic to a component

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
+import org.jetbrains.jet.lang.resolve.java.resolver.SamConversionResolverImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
 import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
@@ -62,6 +63,7 @@ public class InjectorForJavaDescriptorResolver {
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
+    private final SamConversionResolverImpl samConversionResolver;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
     private final SingleModuleClassResolver singleModuleClassResolver;
     private final VirtualFileFinder virtualFileFinder;
@@ -92,9 +94,10 @@ public class InjectorForJavaDescriptorResolver {
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
+        this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
         this.singleModuleClassResolver = new SingleModuleClassResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, singleModuleClassResolver);
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
         this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
+import org.jetbrains.jet.lang.resolve.java.resolver.SamConversionResolverImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
 import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider;
 import org.jetbrains.jet.context.LazyResolveToken;
@@ -93,6 +94,7 @@ public class InjectorForLazyResolveWithJava {
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
+    private final SamConversionResolverImpl samConversionResolver;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
     private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
     private final LazyResolveToken lazyResolveToken;
@@ -154,8 +156,9 @@ public class InjectorForLazyResolveWithJava {
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.lazyResolveBasedCache = new LazyResolveBasedCache();
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
+        this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, moduleClassResolver);
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module);
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module);
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
+import org.jetbrains.jet.lang.resolve.java.resolver.SamConversionResolverImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
 import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider;
@@ -105,6 +106,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
+    private final SamConversionResolverImpl samConversionResolver;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
     private final SingleModuleClassResolver singleModuleClassResolver;
     private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
@@ -172,9 +174,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
+        this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
         this.singleModuleClassResolver = new SingleModuleClassResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, singleModuleClassResolver);
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor());
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);

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

@@ -0,0 +1,31 @@
+/*
+ * 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
+import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaClassDescriptor
+import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
+
+public object SamConversionResolverImpl : SamConversionResolver {
+    override fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor? {
+        val classifier = scope.getClassifier(name) as? LazyJavaClassDescriptor ?: return null
+        if (classifier.getFunctionTypeForSamInterface() == null) return null
+        return SingleAbstractMethodUtils.createSamConstructorFunction(scope.getContainingDeclaration(), classifier)
+    }
+}

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 DeclarationDescriptor containingDeclaration, @NotNull JavaClassDescriptor samInterface) {
-    public SamConstructorDescriptor(
-            @NotNull ClassOrPackageFragmentDescriptor 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.*
-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.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,
+) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder, kotlinClassFinder,
-                            kotlinClassFinder, deserializedDescriptorResolver,
+                            deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, errorReporter,
-                            externalAnnotationResolver, externalSignatureResolver, errorReporter, methodSignatureChecker,
+                            methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver,
-                            javaResolverCache, javaPropertyInitializerEvaluator, sourceElementFactory, moduleClassResolver)
+                            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()
+        result.addIfNotNull(c.samConversionResolver.resolveSamConstructor(name, this))
-        if (samConstructor != null) {
-            result.add(samConstructor)
-        }
     }
 
     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 nestedClassesScope = getContainingDeclaration().getUnsubstitutedInnerClassesScope()
-        val samConstructor = getContainingDeclaration().getUnsubstitutedInnerClassesScope().getClassifier(name)?.createSamConstructor()
+        result.addIfNotNull(c.samConversionResolver.resolveSamConstructor(name, nestedClassesScope))
-        if (samConstructor != null) {
-            result.add(samConstructor)
-        }
     }
 
     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;

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -121,6 +121,7 @@ private fun generatorForTopDownAnalyzerForJvm() =
                     javaClass<PsiBasedExternalAnnotationResolver>(),
                     javaClass<MutablePackageFragmentProvider>(),
                     javaClass<JavaPropertyInitializerEvaluatorImpl>(),
+                    javaClass<SamConversionResolverImpl>(),
                     javaClass<JavaSourceElementFactoryImpl>(),
                     javaClass<SingleModuleClassResolver>(),
                     javaClass<JavaFlexibleTypeCapabilitiesProvider>()
@@ -152,6 +153,7 @@ private fun generatorForJavaDescriptorResolver() =
                     javaClass<PsiBasedMethodSignatureChecker>(),
                     javaClass<PsiBasedExternalAnnotationResolver>(),
                     javaClass<JavaPropertyInitializerEvaluatorImpl>(),
+                    javaClass<SamConversionResolverImpl>(),
                     javaClass<JavaSourceElementFactoryImpl>(),
                     javaClass<SingleModuleClassResolver>()
             )
@@ -188,6 +190,7 @@ private fun generatorForLazyResolveWithJava() =
                     javaClass<PsiBasedMethodSignatureChecker>(),
                     javaClass<PsiBasedExternalAnnotationResolver>(),
                     javaClass<JavaPropertyInitializerEvaluatorImpl>(),
+                    javaClass<SamConversionResolverImpl>(),
                     javaClass<JavaSourceElementFactoryImpl>(),
                     javaClass<JavaFlexibleTypeCapabilitiesProvider>(),
                     javaClass<LazyResolveToken>()