Minor code editings

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

@@ -35,7 +35,6 @@ 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
 import org.jetbrains.jet.lang.types.JetType
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaMemberScope.MethodSignatureData
 
 public class LazyJavaClassMemberScope(
         c: LazyJavaResolverContextWithTypes,
@@ -97,7 +96,7 @@ public class LazyJavaClassMemberScope(
                 propagated.getReceiverType(), propagated.getValueParameters(), propagated.getTypeParameters(),
                 propagated.hasStableParameterNames())
 
-        return MethodSignatureData(effectiveSignature, superFunctions, propagated.getErrors() + effectiveSignature.getErrors())
+        return LazyJavaMemberScope.MethodSignatureData(effectiveSignature, superFunctions, propagated.getErrors() + effectiveSignature.getErrors())
     }
 
     private fun resolveConstructor(constructor: JavaConstructor): JavaConstructorDescriptor {

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

@@ -60,9 +60,7 @@ public abstract class LazyJavaMemberScope(
 
     override fun getContainingDeclaration() = containingDeclaration
 
-    protected val memberIndex: NotNullLazyValue<MemberIndex> = c.storageManager.createLazyValue {
+    protected val memberIndex: NotNullLazyValue<MemberIndex> = c.storageManager.createLazyValue { computeMemberIndex() }
-        computeMemberIndex()
-    }
 
     protected abstract fun computeMemberIndex(): MemberIndex
 
@@ -71,7 +69,9 @@ public abstract class LazyJavaMemberScope(
 
     protected abstract fun getDispatchReceiverParameter(): ReceiverParameterDescriptor?
 
-    private val functions = c.storageManager.createMemoizedFunction {(name: Name): Collection<FunctionDescriptor> ->
+    private val functions = c.storageManager.createMemoizedFunction {
+        (name: Name): Collection<FunctionDescriptor>
+        ->
         val result = LinkedHashSet<SimpleFunctionDescriptor>()
 
         for (method in memberIndex().findMethodsByName(name)) {
@@ -92,14 +92,17 @@ public abstract class LazyJavaMemberScope(
         result.toReadOnlyList()
     }
 
-    data class MethodSignatureData(
+    protected data class MethodSignatureData(
             val effectiveSignature: ExternalSignatureResolver.AlternativeMethodSignature,
             val superFunctions: List<FunctionDescriptor>,
             val errors: List<String>
     )
 
-    abstract fun resolveMethodSignature(method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>,
+    protected abstract fun resolveMethodSignature(
-                                        returnType: JetType, valueParameters: ResolvedValueParameters): MethodSignatureData
+            method: JavaMethod,
+            methodTypeParameters: List<TypeParameterDescriptor>,
+            returnType: JetType,
+            valueParameters: ResolvedValueParameters): MethodSignatureData
 
     fun resolveMethodToFunctionDescriptor(method: JavaMethod, record: Boolean = true): JavaMethodDescriptor {
 
@@ -146,14 +149,13 @@ public abstract class LazyJavaMemberScope(
     }
 
     protected class ResolvedValueParameters(val descriptors: List<ValueParameterDescriptor>, val hasSynthesizedNames: Boolean)
+
     protected fun resolveValueParameters(
             c: LazyJavaResolverContextWithTypes,
             function: FunctionDescriptor,
-            jValueParameters: List<JavaValueParameter>
+            jValueParameters: List<JavaValueParameter>): ResolvedValueParameters {
-    ): ResolvedValueParameters {
         var synthesizedNames = false
-        val descriptors = jValueParameters.withIndices().map {
+        val descriptors = jValueParameters.withIndices().map { pair ->
-            pair ->
             val (index, javaParameter) = pair
 
             val annotations = c.resolveAnnotations(javaParameter)
@@ -161,16 +163,17 @@ public abstract class LazyJavaMemberScope(
             val (outType, varargElementType) =
                 if (javaParameter.isVararg()) {
                     val paramType = javaParameter.getType()
-                    assert (paramType is JavaArrayType, "Vararg parameter should be an array: $paramType")
+                    assert (paramType is JavaArrayType) { "Vararg parameter should be an array: $paramType" }
                     val arrayType = c.typeResolver.transformArrayType(paramType as JavaArrayType, typeUsage, true)
                     val outType = if (PLATFORM_TYPES) arrayType else TypeUtils.makeNotNullable(arrayType)
-                    Pair(outType, KotlinBuiltIns.getInstance().getArrayElementType(outType))
+                    outType to KotlinBuiltIns.getInstance().getArrayElementType(outType)
                 }
                 else {
                     val jetType = c.typeResolver.transformJavaType(javaParameter.getType(), typeUsage)
                     if (!PLATFORM_TYPES && jetType.isNullable() && c.hasNotNullAnnotation(javaParameter))
-                        Pair(TypeUtils.makeNotNullable(jetType), null)
+                        TypeUtils.makeNotNullable(jetType) to null
-                    else Pair(jetType, null)
+                    else
+                        jetType to null
                 }
 
             val name = if (function.getName().asString() == "equals" &&
@@ -291,11 +294,8 @@ public abstract class LazyJavaMemberScope(
         val result = LinkedHashSet<DeclarationDescriptor>()
 
         for (name in getAllClassNames()) {
-            val descriptor = getClassifier(name)
+            // Null signifies that a class found in Java is not present in Kotlin (e.g. package class)
-            if (descriptor != null) {
+            result.addIfNotNull(getClassifier(name))
-                // Null signifies that a class found in Java is not present in Kotlin (e.g. package class)
-                result.add(descriptor)
-            }
         }
 
         for (name in getAllFunctionNames()) {

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

@@ -29,7 +29,6 @@ import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 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.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.lang.resolve.DescriptorFactory.*
 import org.jetbrains.jet.utils.addIfNotNull
@@ -53,7 +52,7 @@ public abstract class LazyJavaStaticScope(
     ): LazyJavaMemberScope.MethodSignatureData {
         val effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature(
                 method, false, returnType, null, valueParameters.descriptors, methodTypeParameters, false)
-        return MethodSignatureData(effectiveSignature, listOf(), effectiveSignature.getErrors())
+        return LazyJavaMemberScope.MethodSignatureData(effectiveSignature, listOf(), effectiveSignature.getErrors())
     }
 
     override fun computeNonDeclaredProperties(name: Name, result: MutableCollection<PropertyDescriptor>) {
@@ -80,8 +79,7 @@ public class LazyPackageFragmentScopeForJavaPackage(
             c.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinBinaryClass) ?: JetScope.Empty
     }
 
-    private val classes = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
+    private val classes = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> { name ->
-        name ->
         val classId = ClassId(packageFragment.fqName, SpecialNames.safeIdentifier(name))
         val (jClass, kClass) = this.c.findClassInJava(classId)
         if (kClass != null)
@@ -90,8 +88,9 @@ public class LazyPackageFragmentScopeForJavaPackage(
             null
         else {
             val classDescriptor = this.c.javaClassResolver.resolveClass(jClass)
-            assert(classDescriptor == null || classDescriptor.getContainingDeclaration() == packageFragment,
+            assert(classDescriptor == null || classDescriptor.getContainingDeclaration() == packageFragment) {
-                   "Wrong package fragment for $classDescriptor, expected $packageFragment")
+                "Wrong package fragment for $classDescriptor, expected $packageFragment"
+            }
             classDescriptor
         }
     }
@@ -140,13 +139,13 @@ public class LazyJavaStaticClassScope(
 ) : LazyJavaStaticScope(c, descriptor) {
 
     override fun computeMemberIndex(): MemberIndex {
-        val delegate = ClassMemberIndex(jClass) { m -> m.isStatic() }
+        val delegate = ClassMemberIndex(jClass) { it.isStatic() }
         return object : MemberIndex by delegate {
             override fun getAllMethodNames(): Collection<Name> {
                 // Should be a super call, but KT-2860
                 return delegate.getAllMethodNames() +
                        // For SAM-constructors
-                       jClass.getInnerClasses().map { c -> c.getName() }
+                       jClass.getInnerClasses().map { it.getName() }
             }
         }
     }