From 09ddfb714e8065bf564269121db0bd79fbda01b0 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Sun, 8 Apr 2012 23:23:59 +0400 Subject: [PATCH] cleanup in JavaDescriptorResolver --- .../jetbrains/jet/codegen/JetTypeMapper.java | 10 +- .../lang/resolve/java/JavaBindingContext.java | 2 +- .../resolve/java/JavaDescriptorResolver.java | 127 +++++++----------- .../lang/resolve/java/JavaNamespaceKind.java | 25 ++++ 4 files changed, 77 insertions(+), 87 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceKind.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 9841ae6565a..a1d7167d2b1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -178,20 +178,20 @@ public class JetTypeMapper { private String jvmClassNameForNamespace(NamespaceDescriptor namespace) { FqName fqName = DescriptorUtils.getFQName(namespace).toSafe(); - Boolean javaClassStatics = bindingContext.get(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespace); + JavaNamespaceKind javaNamespaceKind = bindingContext.get(JavaBindingContext.JAVA_NAMESPACE_KIND, namespace); Boolean src = bindingContext.get(BindingContext.NAMESPACE_IS_SRC, namespace); - if (javaClassStatics == null && src == null) { + if (javaNamespaceKind == null && src == null) { throw new IllegalStateException("unknown namespace origin: " + fqName); } boolean classStatics; - if (javaClassStatics != null) { - if (javaClassStatics.booleanValue() && src != null) { + if (javaNamespaceKind != null) { + if (javaNamespaceKind == JavaNamespaceKind.CLASS_STATICS && src != null) { throw new IllegalStateException( "conflicting namespace " + fqName + ": it is both java statics and from src"); } - classStatics = javaClassStatics.booleanValue(); + classStatics = javaNamespaceKind == JavaNamespaceKind.CLASS_STATICS; } else { classStatics = false; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java index b1d522f54d9..ae598b3dfda 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java @@ -31,7 +31,7 @@ public class JavaBindingContext { /** * @see BindingContext#NAMESPACE_IS_SRC */ - public static final WritableSlice NAMESPACE_IS_CLASS_STATICS = + public static final WritableSlice JAVA_NAMESPACE_KIND = Slices.createSimpleSlice(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 9eaeed8c4e5..4bc355c88e5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -28,6 +28,7 @@ import com.intellij.psi.PsiAnnotationParameterList; import com.intellij.psi.PsiArrayType; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiElement; import com.intellij.psi.PsiEllipsisType; import com.intellij.psi.PsiLiteralExpression; import com.intellij.psi.PsiMethod; @@ -232,6 +233,16 @@ public class JavaDescriptorResolver { classOrNamespaceDescriptor = descriptor; } + @NotNull + public PsiElement getPsiPackageOrPsiClass() { + if (psiPackage != null) { + return psiPackage; + } + else { + return psiClass; + } + } + private Map namedMembersMap; @NotNull @@ -872,78 +883,69 @@ public class JavaDescriptorResolver { } } - PsiPackage psiPackage = psiClassFinder.findPsiPackage(qualifiedName); - if (psiPackage == null) { - PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName); - if (psiClass == null) return null; - return resolveNamespace(psiClass); + ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(qualifiedName); + if (namespaceData != null) { + return namespaceData.namespaceDescriptor; } - return resolveNamespace(psiPackage); - } - private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) { - FqName fqName = new FqName(psiPackage.getQualifiedName()); - ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(fqName); - if (namespaceData == null) { - return createJavaNamespaceDescriptor(psiPackage); + NamespaceDescriptorParent parentNs = resolveParentNamespace(qualifiedName); + if (parentNs == null) { + return null; } - return namespaceData.namespaceDescriptor; - } - private NamespaceDescriptor resolveNamespace(@NotNull PsiClass psiClass) { - FqName fqName = new FqName(psiClass.getQualifiedName()); - ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(fqName); - if (namespaceData == null) { - namespaceData = createJavaNamespaceDescriptor(psiClass); - namespaceDescriptorCacheByFqn.put(fqName, namespaceData); - } - return namespaceData.namespaceDescriptor; - } - - private JavaNamespaceDescriptor createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) { - FqName fqName = new FqName(psiPackage.getQualifiedName()); - String name = psiPackage.getName(); - JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor( - (NamespaceDescriptorParent) resolveParentDescriptor(psiPackage), + JavaNamespaceDescriptor ns = new JavaNamespaceDescriptor( + parentNs, Collections.emptyList(), // TODO - name == null ? JAVA_ROOT : name, - fqName + qualifiedName.isRoot() ? "" : qualifiedName.shortName(), + qualifiedName ); - trace.record(BindingContext.NAMESPACE, psiPackage, namespaceDescriptor); - ResolverNamespaceData scopeData = createNamespaceResolverScopeData(fqName, namespaceDescriptor); - namespaceDescriptor.setMemberScope(scopeData.memberScope); - return namespaceDescriptor; + ResolverNamespaceData scopeData = createNamespaceResolverScopeData(qualifiedName, ns); + if (scopeData == null) { + return null; + } + + trace.record(BindingContext.NAMESPACE, scopeData.getPsiPackageOrPsiClass(), ns); + + ns.setMemberScope(scopeData.memberScope); + + return scopeData.namespaceDescriptor; + } + + private NamespaceDescriptorParent resolveParentNamespace(FqName fqName) { + if (fqName.isRoot()) { + return FAKE_ROOT_MODULE; + } else { + return resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN); + } } @Nullable private ResolverNamespaceData createNamespaceResolverScopeData(@NotNull FqName fqName, @NotNull NamespaceDescriptor ns) { PsiPackage psiPackage; - psiPackage = semanticServices.getPsiClassFinder().findPsiPackage(fqName); PsiClass psiClass; lookingForPsi: { psiClass = getPsiClassForJavaPackageScope(fqName); + psiPackage = semanticServices.getPsiClassFinder().findPsiPackage(fqName); if (psiClass != null || psiPackage != null) { + trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.PROPER); break lookingForPsi; } psiClass = psiClassFinder.findPsiClass(fqName); - if (psiClass == null) { - return null; + if (psiClass != null) { + trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.CLASS_STATICS); + break lookingForPsi; } - } - if (psiPackage != null) { - trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, ns, false); + return null; } ResolverNamespaceData namespaceData = new ResolverNamespaceData(psiClass, psiPackage, fqName, ns); - JavaPackageScope scope = new JavaPackageScope(fqName, semanticServices, namespaceData); - - namespaceData.memberScope = scope; + namespaceData.memberScope = new JavaPackageScope(fqName, semanticServices, namespaceData); ResolverNamespaceData oldValue = namespaceDescriptorCacheByFqn.put(fqName, namespaceData); if (oldValue != null) { @@ -974,43 +976,6 @@ public class JavaDescriptorResolver { return psiClassFinder.findPsiClass(packageFQN.child(JvmAbi.PACKAGE_CLASS)); } - @NotNull - private DeclarationDescriptor resolveParentDescriptor(@NotNull PsiPackage psiPackage) { - PsiPackage parentPackage = psiPackage.getParentPackage(); - if (parentPackage == null) { - return FAKE_ROOT_MODULE; - } - return resolveNamespace(parentPackage); - } - - /** - * TODO - * @see #createClassObjectDescriptor(org.jetbrains.jet.lang.descriptors.ClassDescriptor, com.intellij.psi.PsiClass) - */ - private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) { - - checkPsiClassIsNotJet(psiClass); - - FqName fqName = new FqName(psiClass.getQualifiedName()); - JavaNamespaceDescriptor ns = new JavaNamespaceDescriptor( - resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN), - Collections.emptyList(), // TODO - psiClass.getName(), - fqName - ); - - ResolverNamespaceData scopeData = createNamespaceResolverScopeData(fqName, ns); - if (scopeData == null) { - throw new IllegalStateException("we have class: " + fqName); - } - - ns.setMemberScope(scopeData.memberScope); - trace.record(BindingContext.NAMESPACE, psiClass, ns); - trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, ns, true); - - return scopeData; - } - private static class ValueParameterDescriptors { private final JetType receiverType; private final List descriptors; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceKind.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceKind.java new file mode 100644 index 00000000000..0b227790f79 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceKind.java @@ -0,0 +1,25 @@ +/* + * Copyright 2010-2012 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; + +/** + * @author Stepan Koltsov + */ +public enum JavaNamespaceKind { + PROPER, + CLASS_STATICS, +}