diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaSubModule.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaSubModule.kt
index 44277b48a03..6666ff29096 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaSubModule.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaSubModule.kt
@@ -5,11 +5,52 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragment
 import org.jetbrains.jet.storage.MemoizedFunctionToNullable
 import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 
 public open class LazyJavaSubModule(
-        c: LazyJavaResolverContext,
+        private val outerContext: LazyJavaResolverContext,
         module: ModuleDescriptor
 ) {
-    public val packageFragments: MemoizedFunctionToNullable<FqName, NamespaceDescriptor>
-            = c.storageManager.createMemoizedFunctionWithNullableValues {fqName -> LazyJavaPackageFragment(c, module, fqName)}
+    private val c = LazyJavaResolverContext(
+            outerContext.storageManager,
+            outerContext.finder,
+            SubModuleClassResolver(),
+            outerContext.externalAnnotationResolver
+    )
+
+    private val _packageFragments: MemoizedFunctionToNullable<FqName, NamespaceDescriptor> = c.storageManager.createMemoizedFunctionWithNullableValues {
+        fqName ->
+        val parent = if (fqName.isRoot()) module else getPackageFragment(fqName.parent()) ?: throw IllegalStateException("Cannot resolve parent package for: $fqName")
+        LazyJavaPackageFragment(c, parent, fqName)
+    }
+
+    fun getPackageFragment(fqName: FqName): NamespaceDescriptor? = _packageFragments(fqName)
+
+    fun getClass(fqName: FqName): ClassDescriptor? = c.javaClassResolver.resolveClassByFqName(fqName)
+
+    private inner class SubModuleClassResolver : LazyJavaClassResolver {
+        override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
+            // TODO: there's no notion of module separation here. We must refuse to resolve classes from other modules
+            val outer = javaClass.getOuterClass()
+            val scope = if (outer != null) {
+                val outerClass = resolveClass(outer)
+                if (outerClass == null) return outerContext.javaClassResolver.resolveClass(javaClass)
+                outerClass.getUnsubstitutedInnerClassesScope()
+            }
+            else {
+                val outerPackage = getPackageFragment(javaClass.getFqName()!!.parent())
+                if (outerPackage == null) return outerContext.javaClassResolver.resolveClass(javaClass)
+                outerPackage.getMemberScope()
+            }
+            return scope.getClassifier(javaClass.getName()) as? ClassDescriptor
+        }
+
+        override fun resolveClassByFqName(fqName: FqName): ClassDescriptor? {
+            val jClass = c.finder.findClass(fqName)
+            if (jClass == null) return null
+
+            return resolveClass(jClass)
+        }
+    }
 }
\ No newline at end of file