Extract JavaConstructor out of JavaMethod

Will be useful in reflection-backed implementation of Java structure, where Constructor is not a Method and doesn't even inherit from it
2014-08-29 14:42:12 +04:00
parent 04ff45dee3
commit 924283d2d9
18 changed files with 167 additions and 71 deletions
@@ -29,12 +29,11 @@ public class JavaDescriptorResolver(public val packageFragmentProvider: LazyJava
 }

 public fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): FunctionDescriptor? {
-    val functions = if (method.isConstructor())
-                        resolveClass(method.getContainingClass())?.getConstructors()
-                    else
-                        getContainingScope(method)?.getFunctions(method.getName())
+    return getContainingScope(method)?.getFunctions(method.getName())?.findByJavaElement(method)
+}

-    return functions?.findByJavaElement(method)
+public fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
+    return resolveClass(constructor.getContainingClass())?.getConstructors()?.findByJavaElement(constructor)
 }

 public fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
@@ -18,11 +18,9 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors

 import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
-import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
+import org.jetbrains.jet.lang.resolve.java.structure.*
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl
-import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage
 import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl
 import java.util.Collections
@@ -54,9 +52,8 @@ public class LazyJavaClassMemberScope(
    }

    internal val _constructors = c.storageManager.createLazyValue {
-        jClass.getConstructors().flatMap {
-            jCtor ->
-            val constructor = resolveConstructor(jCtor, getContainingDeclaration())
+        jClass.getConstructors().flatMap { ctor ->
+            val constructor = resolveConstructor(ctor, getContainingDeclaration())
            val samAdapter = resolveSamAdapter(constructor)
            if (samAdapter != null) {
                samAdapter.setReturnType(containingDeclaration.getDefaultType())
@@ -116,7 +113,7 @@ public class LazyJavaClassMemberScope(
               else null
    }

-    private fun resolveConstructor(constructor: JavaMethod, classDescriptor: ClassDescriptor): JavaConstructorDescriptor {
+    private fun resolveConstructor(constructor: JavaConstructor, classDescriptor: ClassDescriptor): JavaConstructorDescriptor {
        val constructorDescriptor = JavaConstructorDescriptor.createJavaConstructor(
                classDescriptor, Annotations.EMPTY, /* isPrimary = */ false, c.sourceElementFactory.source(constructor)
        )
@@ -20,7 +20,6 @@ import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
-import org.jetbrains.jet.lang.descriptors.Visibilities
 import org.jetbrains.jet.lang.resolve.java.structure.JavaField
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMember
 import org.jetbrains.jet.utils.valuesToMap
@@ -44,20 +43,15 @@ object EMPTY_MEMBER_INDEX : MemberIndex {
 open class ClassMemberIndex(val jClass: JavaClass, val memberFilter: (JavaMember) -> Boolean) : MemberIndex {
    private val methodFilter = {
        (m: JavaMethod) ->
-        memberFilter(m) &&
-        !m.isConstructor() &&
-        !DescriptorResolverUtils.isObjectMethodInInterface(m)
+        memberFilter(m) && !DescriptorResolverUtils.isObjectMethodInInterface(m)
    }

    private val methods = jClass.getMethods().stream().filter(methodFilter).groupBy { m -> m.getName() }
    private val fields = jClass.getFields().stream().filter(memberFilter).valuesToMap { m -> m.getName() }

-    override fun findMethodsByName(name: Name): Collection<JavaMethod> {
-        return methods[name] ?: listOf()
-    }
-
-    override fun getAllMethodNames(): Collection<Name> = jClass.getAllMethods().iterator().filter(methodFilter).map { m -> m.getName() }.toList()
+    override fun findMethodsByName(name: Name): Collection<JavaMethod> = methods[name] ?: listOf()
+    override fun getAllMethodNames(): Collection<Name> = jClass.getAllMethods().stream().filter(methodFilter).map { m -> m.getName() }.toList()

    override fun findFieldByName(name: Name): JavaField? = fields[name]
    override fun getAllFieldNames() = jClass.getAllFields().stream().filter(memberFilter).map { m -> m.getName() }.toList()
-}
+}
@@ -16,28 +16,19 @@

 package org.jetbrains.jet.lang.resolve.java.lazy.types

-import org.jetbrains.jet.lang.resolve.java.structure.JavaType
+import org.jetbrains.jet.lang.resolve.java.structure.*
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.resolve.java.structure.JavaWildcardType
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage.*
 import org.jetbrains.jet.lang.resolve.java.resolver.*
 import org.jetbrains.jet.lang.types.Variance.*
 import org.jetbrains.jet.lang.types.*
-import org.jetbrains.jet.lang.resolve.java.structure.JavaPrimitiveType
-import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
-import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.kotlin.util.sure
-import org.jetbrains.jet.utils.*
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationOwner
 import org.jetbrains.jet.lang.resolve.java.lazy.*
 import org.jetbrains.jet.storage.*
-import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import java.util.HashSet
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker

@@ -132,17 +123,15 @@ class LazyJavaTypeResolver(
        }

        private fun isConstructorTypeParameter(): Boolean {
-            val cl = classifier()
-            if (cl !is JavaTypeParameter) return false
-            val owner = cl.getOwner()
-            return owner is JavaMethod && owner.isConstructor()
+            val classifier = classifier()
+            return classifier is JavaTypeParameter && classifier.getOwner() is JavaConstructor
        }

        // We do not memoize the results of this method, because it would consume much memory, and the real gain is little:
        // the case this method accounts for is very rare, not point in optimizing it
        private fun getConstructorTypeParameterSubstitute(): JetType {
            // If a Java-constructor declares its own type parameters, we have no way of directly expressing them in Kotlin,
-            // so we replace thwm by intersections of their upper bounds
+            // so we replace them by intersections of their upper bounds
            val supertypesJet = HashSet<JetType>()
            for (supertype in (classifier() as JavaTypeParameter).getUpperBounds()) {
                supertypesJet.add(transformJavaType(supertype, UPPER_BOUND.toAttributes()))
@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaField;
+import org.jetbrains.jet.lang.resolve.java.structure.JavaMember;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod;
 import org.jetbrains.jet.lang.types.JetType;

@@ -136,7 +137,7 @@ public interface ExternalSignatureResolver {

    @NotNull
    AlternativeMethodSignature resolveAlternativeMethodSignature(
-            @NotNull JavaMethod method,
+            @NotNull JavaMember methodOrConstructor,
            boolean hasSuperMethods,
            @Nullable JetType returnType,
            @Nullable JetType receiverType,
@@ -375,9 +375,7 @@ public class SingleAbstractMethodUtils {
                @NotNull JavaMethod method2,
                @NotNull JavaTypeSubstitutor substitutor2
        ) {
-            if (method1.isConstructor() != method2.isConstructor()) return false;
-            if (!method1.isConstructor() && !method1.getName().equals(method2.getName())) return false;
-
+            if (!method1.getName().equals(method2.getName())) return false;
            if (method1.isVararg() != method2.isVararg()) return false;

            Collection<JavaValueParameter> parameters1 = method1.getValueParameters();
@@ -54,7 +54,7 @@ public interface JavaClass extends JavaClassifier, JavaTypeParameterListOwner, J
    Collection<JavaField> getAllFields();

    @NotNull
-    Collection<JavaMethod> getConstructors();
+    Collection<JavaConstructor> getConstructors();

    @NotNull
    JavaClassifierType getDefaultType();
@@ -0,0 +1,26 @@
+/*
+ * 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.structure;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public interface JavaConstructor extends JavaMember, JavaTypeParameterListOwner {
+    @NotNull
+    List<JavaValueParameter> getValueParameters();
+}
@@ -31,6 +31,4 @@ public interface JavaMethod extends JavaMember, JavaTypeParameterListOwner {
    JavaType getReturnType();

    boolean isVararg();
-
-    boolean isConstructor();
 }