azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Loading deseralized descriptors integrated with loading from bare Java code

Browse Source
This commit is contained in:
Andrey Breslav
2013-12-31 21:01:25 +04:00
parent 672594cb92
commit 2e4d166d6f
6 changed files with 82 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+2 -65
View File
@@ -16,31 +16,24 @@
package org.jetbrains.jet.lang.resolve.java;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
import org.jetbrains.jet.lang.resolve.ImportPath;
import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolver;
import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
import org.jetbrains.jet.lang.resolve.java.resolver.*;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder;
import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
import javax.inject.Inject;
import java.util.Collections;
import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
@@ -55,23 +48,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
private final MemoizedFunctionToNullable<FqName, ClassDescriptor> kotlinClassesFromBinaries = storageManager.createMemoizedFunctionWithNullableValues(
new Function1<FqName, ClassDescriptor>() {
@Override
public ClassDescriptor invoke(FqName fqName) {
//TODO: correct scope
KotlinJvmBinaryClass kotlinClass = kotlinClassFinder.find(fqName);
if (kotlinClass != null) {
ClassDescriptor deserializedDescriptor = deserializedDescriptorResolver.resolveClass(kotlinClass);
if (deserializedDescriptor != null) {
return deserializedDescriptor;
}
}
return null;
}
}
);
private JavaClassResolver classResolver;
private JavaPackageFragmentProvider packageFragmentProvider;
private JavaClassFinder javaClassFinder;
@@ -150,36 +126,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(
new GlobalJavaResolverContext(
storageManager,
new JavaClassFinder() {
@Nullable
@Override
public JavaClass findClass(@NotNull FqName fqName) {
// Do not look for JavaClasses for Kotlin binaries & built-ins
if (kotlinClassesFromBinaries.invoke(fqName) != null
//|| kotlinNamespacesFromBinaries.invoke(fqName) != null
|| JavaClassResolver.getKotlinBuiltinClassDescriptor(fqName) != null) {
return null;
}
JavaClass javaClass = javaClassFinder.findClass(fqName);
if (javaClass == null) {
return null;
}
// Light classes are not proper binaries either
if (javaClass.getOriginKind() == JavaClass.OriginKind.KOTLIN_LIGHT_CLASS) {
return null;
}
return javaClass;
}
@Nullable
@Override
public JavaPackage findPackage(@NotNull FqName fqName) {
return javaClassFinder.findPackage(fqName);
}
},
javaClassFinder,
kotlinClassFinder,
deserializedDescriptorResolver,
new LazyJavaClassResolver() {
@@ -195,17 +142,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
@Override
public ClassDescriptor resolveClassByFqName(FqName fqName) {
ClassDescriptor kotlinClassDescriptor = javaResolverCache.getClassResolvedFromSource(fqName);
if (kotlinClassDescriptor != null) {
return kotlinClassDescriptor;
}
ClassDescriptor classFromBinaries = kotlinClassesFromBinaries.invoke(fqName);
if (classFromBinaries != null) {
return classFromBinaries;
}
return null;
return javaResolverCache.getClassResolvedFromSource(fqName);
}
},
externalAnnotationResolver,
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt
+15 -4
View File
@@ -12,6 +12,8 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragment
import org.jetbrains.jet.lang.resolve.name.Name
import org.jetbrains.jet.lang.resolve.scopes.JetScope
import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
public open class LazyJavaPackageFragmentProvider(
private val outerContext: GlobalJavaResolverContext,
@@ -43,7 +45,7 @@ public open class LazyJavaPackageFragmentProvider(
LazyPackageFragmentForJavaPackage(c, _module, jPackage)
}
else {
val jClass = c.finder.findClass(fqName)
val jClass = c.findJavaClass(fqName)
if (jClass != null && DescriptorResolverUtils.isJavaClassVisibleAsPackage(jClass)) {
LazyPackageFragmentForJavaClass(c, _module, jClass)
}
@@ -61,14 +63,22 @@ public open class LazyJavaPackageFragmentProvider(
fun getClass(fqName: FqName): ClassDescriptor? = c.javaClassResolver.resolveClassByFqName(fqName)
internal val resolveKotlinBinaryClass = c.storageManager.createMemoizedFunctionWithNullableValues {
(kotlinClass: KotlinJvmBinaryClass) -> c.deserializedDescriptorResolver.resolveClass(kotlinClass)
}
private inner class FragmentClassResolver : 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 fqName = javaClass.getFqName()
if (fqName != null) {
// TODO: this should be handled by module seperation logic
// TODO: this should be handled by module separation logic
val builtinClass = JavaClassResolver.getKotlinBuiltinClassDescriptor(fqName)
if (builtinClass != null) return builtinClass
if (javaClass.getOriginKind() == JavaClass.OriginKind.KOTLIN_LIGHT_CLASS) {
return c.javaResolverCache.getClassResolvedFromSource(fqName)
}
}
val outer = javaClass.getOuterClass()
@@ -83,15 +93,16 @@ public open class LazyJavaPackageFragmentProvider(
outerPackage.getMemberScope()
}
return scope.getClassifier(javaClass.getName()) as? ClassDescriptor
?: outerContext.javaClassResolver.resolveClass(javaClass)
}
override fun resolveClassByFqName(fqName: FqName): ClassDescriptor? {
val builtinClass = JavaClassResolver.getKotlinBuiltinClassDescriptor(fqName)
if (builtinClass != null) return builtinClass
val jClass = c.finder.findClass(fqName)
val (jClass, kClass) = c.findClassInJava(fqName)
if (jClass != null) return resolveClass(jClass)
if (kClass != null) return resolveKotlinBinaryClass(kClass)
return outerContext.javaClassResolver.resolveClassByFqName(fqName)
}
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt
+6
View File
@@ -303,9 +303,15 @@ public abstract class LazyJavaMemberScope(
result.addAll(getProperties(name))
}
addExtraDescriptors(result)
return result
}
protected open fun addExtraDescriptors(result: MutableSet<DeclarationDescriptor>) {
// Do nothing
}
protected abstract fun getAllPackageNames(): Collection<Name>
protected abstract fun getAllClassNames(): Collection<Name>
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragmentScope.kt
+29 -8
View File
@@ -12,8 +12,12 @@ 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.kotlin.util.inn
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule
import org.jetbrains.kotlin.util.sure
import org.jetbrains.jet.lang.resolve.java.lazy.findJavaClass
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.storage.NotNullLazyValue
public abstract class LazyJavaPackageFragmentScope(
c: LazyJavaResolverContext,
@@ -24,22 +28,24 @@ public abstract class LazyJavaPackageFragmentScope(
private val classes = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
name ->
val fqName = fqName.child(name)
val javaClass = c.finder.findClass(fqName)
if (javaClass == null)
c.javaClassResolver.resolveClassByFqName(fqName)
val (jClass, kClass) = c.findClassInJava(fqName)
if (kClass != null)
c.packageFragmentProvider.resolveKotlinBinaryClass(kClass)
else if (jClass == null)
null
else {
// TODO: this caching is a temporary workaround, should be replaced with properly caching the whole LazyJavaSubModule
val cached = c.javaResolverCache.getClass(javaClass)
val cached = c.javaResolverCache.getClass(jClass)
if (cached != null)
cached
else
LazyJavaClassDescriptor(c.withTypes(TypeParameterResolver.EMPTY), packageFragment, fqName, javaClass)
LazyJavaClassDescriptor(c.withTypes(TypeParameterResolver.EMPTY), packageFragment, fqName, jClass)
}
}
protected fun computeMemberIndexForSamConstructors(delegate: MemberIndex): MemberIndex = object : MemberIndex by delegate {
override fun getAllMethodNames(): Collection<Name> {
val jClass = c.finder.findClass(fqName)
val jClass = c.findJavaClass(fqName)
return delegate.getAllMethodNames() +
// For SAM-constructors
getAllClassNames() +
@@ -66,6 +72,22 @@ public class LazyPackageFragmentScopeForJavaPackage(
packageFragment: LazyJavaPackageFragment
) : LazyJavaPackageFragmentScope(c, packageFragment) {
private val deserializedPackageScope = c.storageManager.createLazyValue {
val packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName)
val kotlinBinaryClass = c.kotlinClassFinder.findKotlinClass(packageClassFqName)
if (kotlinBinaryClass == null)
JetScope.EMPTY
else
c.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinBinaryClass) ?: JetScope.EMPTY
}
override fun getProperties(name: Name) = deserializedPackageScope().getProperties(name)
override fun getFunctions(name: Name) = deserializedPackageScope().getFunctions(name) + super.getFunctions(name)
override fun addExtraDescriptors(result: MutableSet<DeclarationDescriptor>) {
result.addAll(deserializedPackageScope().getAllDescriptors())
}
override fun computeMemberIndex(): MemberIndex = computeMemberIndexForSamConstructors(EMPTY_MEMBER_INDEX)
override fun getAllClassNames(): Collection<Name> {
@@ -83,7 +105,6 @@ public class LazyPackageFragmentScopeForJavaPackage(
).flatten()
override fun getProperties(name: Name): Collection<VariableDescriptor> = Collections.emptyList()
override fun getAllPropertyNames() = Collections.emptyList<Name>()
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt
+27 -1
View File
@@ -20,10 +20,11 @@ import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
import org.jetbrains.jet.lang.descriptors.ClassDescriptor
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter
import org.jetbrains.jet.utils.valuesToMap
import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaTypeParameterDescriptor
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
import org.jetbrains.jet.lang.resolve.name.FqName
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver
import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
trait LazyJavaClassResolver {
fun resolveClass(javaClass: JavaClass): ClassDescriptor?
@@ -60,4 +61,29 @@ class LazyJavaTypeParameterResolver(
override fun resolveTypeParameter(javaTypeParameter: JavaTypeParameter): TypeParameterDescriptor? {
return resolve(javaTypeParameter) ?: c.typeParameterResolver.resolveTypeParameter(javaTypeParameter)
}
}
fun GlobalJavaResolverContext.findJavaClass(fqName: FqName): JavaClass? = findClassInJava(fqName).jClass
data class JavaClassLookupResult(val jClass: JavaClass? = null, val kClass: KotlinJvmBinaryClass? = null)
fun GlobalJavaResolverContext.findClassInJava(fqName: FqName): JavaClassLookupResult {
// TODO: this should be governed by module separation logic
// Do not look for JavaClasses for Kotlin binaries & built-ins
if (JavaClassResolver.getKotlinBuiltinClassDescriptor(fqName) != null) {
return JavaClassLookupResult()
}
// Do not look for Kotlin binary classes
val kotlinClass = kotlinClassFinder.findKotlinClass(fqName)
if (kotlinClass != null) return JavaClassLookupResult(kClass = kotlinClass)
val javaClass = finder.findClass(fqName)
if (javaClass == null) return JavaClassLookupResult()
// Light classes are not proper binaries either
if (javaClass.getOriginKind() == JavaClass.OriginKind.KOTLIN_LIGHT_CLASS) return JavaClassLookupResult()
return JavaClassLookupResult(javaClass)
}