Support SAM constructors

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

@@ -57,7 +57,10 @@ public class LazyJavaClassMemberScope(
         private val jClass: JavaClass
 ) : LazyJavaMemberScope(c, containingDeclaration) {
 
-    override fun computeMemberIndex(): MemberIndex = ClassMemberIndex(jClass, mustBeStatic = false)
+    override fun computeMemberIndex(): MemberIndex = object : ClassMemberIndex(jClass, mustBeStatic = false) {
+        // For SAM-constructors
+        override fun getAllMetodNames(): Collection<Name> = super.getAllMetodNames() + getAllClassNames()
+    }
 
     internal val _constructors = c.storageManager.createLazyValue {
         jClass.getConstructors().flatMap {

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

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.jet.utils.Printer
 import org.jetbrains.jet.lang.resolve.java.resolver.ExternalSignatureResolver
+import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
 
 public abstract class LazyJavaMemberScope(
         protected val c: LazyJavaResolverContextWithTypes,
@@ -76,6 +77,13 @@ public abstract class LazyJavaMemberScope(
                 listOf(function)
         })
 
+        if (_containingDeclaration is NamespaceDescriptor) {
+            val klass = JavaFunctionResolver.findClassInNamespace(_containingDeclaration, name);
+            if (klass != null && klass.getFunctionTypeForSamInterface() != null) {
+                functions.add(SingleAbstractMethodUtils.createSamConstructorFunction(_containingDeclaration, klass))
+            }
+        }
+
         if (_containingDeclaration is ClassDescriptor) {
             val functionsFromSupertypes = JavaFunctionResolver.getFunctionsFromSupertypes(name, _containingDeclaration);
 

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

@@ -12,6 +12,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.utils.flatten
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver
+import org.jetbrains.kotlin.util.inn
 
 public abstract class LazyJavaPackageFragmentScope(
         c: LazyJavaResolverContext,
@@ -29,6 +30,16 @@ public abstract class LazyJavaPackageFragmentScope(
             LazyJavaClassDescriptor(c.withTypes(TypeParameterResolver.EMPTY), packageFragment, fqName, javaClass)
     }
 
+    protected fun computeMemberIndexForSamConstructors(delegate: MemberIndex): MemberIndex = object : MemberIndex by delegate {
+        override fun getAllMetodNames(): Collection<Name> {
+            val jClass = c.finder.findClass(fqName)
+            return delegate.getAllMetodNames() +
+                   // For SAM-constructors
+                   getAllClassNames() +
+                   jClass.inn({ jC -> jC.getInnerClasses().map { c -> c.getName() }}, listOf())
+        }
+    }
+
     override fun addExtraDescriptors(result: MutableCollection<in DeclarationDescriptor>) {
         // no extra descriptors
     }
@@ -48,12 +59,10 @@ public class LazyPackageFragmentScopeForJavaPackage(
         packageFragment: LazyJavaPackageFragment
 ) : LazyJavaPackageFragmentScope(c, packageFragment) {
 
-    override fun computeMemberIndex(): MemberIndex = EMPTY_MEMBER_INDEX
+    override fun computeMemberIndex(): MemberIndex = computeMemberIndexForSamConstructors(EMPTY_MEMBER_INDEX)
 
     override fun getAllClassNames(): Collection<Name> {
-        val javaPackage = c.finder.findPackage(fqName)
-        assert(javaPackage != null) { "Package not found:  $fqName" }
-        return javaPackage!!.getClasses().map { c -> c.getName() }
+        return jPackage.getClasses().map { c -> c.getName() }
     }
 
     override fun getAllPackageNames(): Collection<Name> =
@@ -73,7 +82,8 @@ public class LazyPackageFragmentScopeForJavaClass(
         packageFragment: LazyJavaPackageFragment
 ) : LazyJavaPackageFragmentScope(c, packageFragment) {
 
-    override fun computeMemberIndex(): MemberIndex = ClassMemberIndex(jClass, mustBeStatic = true)
+    override fun computeMemberIndex(): MemberIndex = computeMemberIndexForSamConstructors(ClassMemberIndex(jClass, mustBeStatic = true))
+
     // nested classes are loaded as members of their outer classes, not packages
     override fun getAllClassNames(): Collection<Name> = listOf()
     override fun getClassifier(name: Name): ClassifierDescriptor? = null

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

@@ -41,7 +41,7 @@ object EMPTY_MEMBER_INDEX : MemberIndex {
     override fun getAllFieldNames() = listOf<Name>()
 }
 
-class ClassMemberIndex(val jClass: JavaClass, mustBeStatic: Boolean) : MemberIndex {
+open class ClassMemberIndex(val jClass: JavaClass, mustBeStatic: Boolean) : MemberIndex {
     private val memberFilter = {
         (m: JavaMember) ->
         m.isStatic() == mustBeStatic &&