From 8517fe6878659666c914be2ce2c86d46d59f3bc0 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Fri, 23 Mar 2012 23:44:16 +0400 Subject: [PATCH] store namespace kind in trace, kill some JavaNamespaceDescriptor usages JavaNamespaceDescriptor will be killed soon --- .../jetbrains/jet/codegen/JetTypeMapper.java | 42 ++++++++++++------- .../di/InjectorForJavaSemanticServices.java | 1 + .../di/InjectorForTopDownAnalyzerForJvm.java | 1 + .../lang/resolve/java/JavaBindingContext.java | 37 ++++++++++++++++ .../resolve/java/JavaDescriptorResolver.java | 3 ++ .../jet/lang/resolve/BindingContext.java | 5 +++ .../lang/resolve/NamespaceFactoryImpl.java | 6 ++- .../jet/compiler/NamespaceComparator.java | 32 ++++---------- 8 files changed, 87 insertions(+), 40 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 22daf6b3747..9b3355ccd2e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; @@ -112,11 +113,8 @@ public class JetTypeMapper { public String getOwner(DeclarationDescriptor descriptor, OwnerKind kind) { String owner; DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration instanceof JavaNamespaceDescriptor) { - JavaNamespaceDescriptor javaNamespaceDescriptor = (JavaNamespaceDescriptor) containingDeclaration; - owner = NamespaceCodegen.getJVMClassName(DescriptorUtils.getFQName(containingDeclaration).toSafe(), javaNamespaceDescriptor.isNamespace()); - } else if (containingDeclaration instanceof NamespaceDescriptor) { - owner = NamespaceCodegen.getJVMClassName(DescriptorUtils.getFQName(containingDeclaration).toSafe(), true); + if (containingDeclaration instanceof NamespaceDescriptor) { + owner = jvmClassNameForNamespace((NamespaceDescriptor) containingDeclaration); } else if (containingDeclaration instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; @@ -140,6 +138,29 @@ public class JetTypeMapper { return owner; } + private String jvmClassNameForNamespace(NamespaceDescriptor namespace) { + FqName fqName = DescriptorUtils.getFQName(namespace).toSafe(); + Boolean javaClassStatics = bindingContext.get(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespace); + Boolean src = bindingContext.get(BindingContext.NAMESPACE_IS_SRC, namespace); + + if (javaClassStatics == null && src == null) { + throw new IllegalStateException("unknown namespace origin: " + fqName); + } + + boolean classStatics; + if (javaClassStatics != null) { + if (javaClassStatics.booleanValue() && src != null) { + throw new IllegalStateException( + "conflicting namespace " + fqName + ": it is both java statics and from src"); + } + classStatics = javaClassStatics.booleanValue(); + } else { + classStatics = false; + } + + return NamespaceCodegen.getJVMClassName(fqName, !classStatics); + } + @NotNull public Type mapReturnType(@NotNull final JetType jetType) { return mapReturnType(jetType, null); } @@ -218,12 +239,9 @@ public class JetTypeMapper { if (container instanceof ModuleDescriptor) { throw new IllegalStateException("missed something"); } - if(container instanceof JavaNamespaceDescriptor && JavaDescriptorResolver.JAVA_ROOT.equals(container.getName())) { - return name; - } String baseName = getFQName(container); if (!baseName.isEmpty()) { - return baseName + (container instanceof JavaNamespaceDescriptor || container instanceof NamespaceDescriptor ? "/" : "$") + name; + return baseName + (container instanceof NamespaceDescriptor ? "/" : "$") + name; } } @@ -391,11 +409,7 @@ public class JetTypeMapper { ClassDescriptor thisClass; if (functionParent instanceof NamespaceDescriptor) { assert !superCall; - boolean namespace = true; - if (functionParent instanceof JavaNamespaceDescriptor) { - namespace = ((JavaNamespaceDescriptor) functionParent).isNamespace(); - } - owner = NamespaceCodegen.getJVMClassName(DescriptorUtils.getFQName(functionParent).toSafe(), namespace); + owner = jvmClassNameForNamespace((NamespaceDescriptor) functionParent); ownerForDefaultImpl = ownerForDefaultParam = owner; invokeOpcode = INVOKESTATIC; thisClass = null; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index b1e4baf061b..8e7e5bbaf01 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -55,6 +55,7 @@ public class InjectorForJavaSemanticServices { this.javaDescriptorResolver.setNamespaceFactory(namespaceFactoryImpl); this.javaDescriptorResolver.setProject(project); this.javaDescriptorResolver.setSemanticServices(javaSemanticServices); + this.javaDescriptorResolver.setTrace(bindingTrace); javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); javaBridgeConfiguration.setProject(project); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 008063aa7d7..fa4b996fde1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -190,6 +190,7 @@ public class InjectorForTopDownAnalyzerForJvm { javaDescriptorResolver.setNamespaceFactory(namespaceFactoryImpl); javaDescriptorResolver.setProject(project); javaDescriptorResolver.setSemanticServices(javaSemanticServices); + javaDescriptorResolver.setTrace(observableBindingTrace); javaTypeTransformer.setJavaSemanticServices(javaSemanticServices); javaTypeTransformer.setResolver(javaDescriptorResolver); 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 new file mode 100644 index 00000000000..b1d522f54d9 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBindingContext.java @@ -0,0 +1,37 @@ +/* + * 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; + +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.util.slicedmap.Slices; +import org.jetbrains.jet.util.slicedmap.WritableSlice; + +/** + * @author Stepan Koltsov + * + * @see BindingContext + */ +public class JavaBindingContext { + + /** + * @see BindingContext#NAMESPACE_IS_SRC + */ + public static final WritableSlice NAMESPACE_IS_CLASS_STATICS = + 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 3bcf4a12391..03ebd7ec9ec 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 @@ -905,6 +905,7 @@ public class JavaDescriptorResolver { name == null ? FqName.ROOT : new FqName(psiPackage.getQualifiedName()), true ); + trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespaceData.namespaceDescriptor, false); namespaceData.namespaceDescriptor.setMemberScope(createJavaPackageScope(new FqName(psiPackage.getQualifiedName()), namespaceData.namespaceDescriptor)); trace.record(BindingContext.NAMESPACE, psiPackage, namespaceData.namespaceDescriptor); @@ -942,6 +943,8 @@ public class JavaDescriptorResolver { new FqName(psiClass.getQualifiedName()), false ); + trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespaceData.namespaceDescriptor, true); + namespaceData.namespaceDescriptor.setMemberScope(new JavaClassMembersScope(namespaceData.namespaceDescriptor, psiClass, semanticServices, true)); trace.record(BindingContext.NAMESPACE, psiClass, namespaceData.namespaceDescriptor); return namespaceData; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index 2615c7a2c50..cf6ba13c1e1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -173,6 +173,11 @@ public interface BindingContext { WritableSlice FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice(DO_NOTHING, true); WritableSlice FQNAME_TO_NAMESPACE_DESCRIPTOR = new BasicWritableSlice(DO_NOTHING); + + /** + * Each namespace found in src must be registered here. + */ + WritableSlice NAMESPACE_IS_SRC = Slices.createSimpleSlice(); WritableSlice INCOMPLETE_HIERARCHY = Slices.createCollectiveSetSlice(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java index 1207d451ba4..2abde869b54 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java @@ -80,6 +80,7 @@ public class NamespaceFactoryImpl implements NamespaceFactory { String namespaceName = JetPsiUtil.safeName(nameExpression.getReferencedName()); NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(null, currentOwner, namespaceName, false); + trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true); currentOwner = namespaceDescriptor; @@ -92,7 +93,10 @@ public class NamespaceFactoryImpl implements NamespaceFactory { String name = JetPsiUtil.safeName(namespaceHeader.getName()); trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope); - return createNamespaceDescriptorIfNeeded(file, currentOwner, name, false); + NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(file, currentOwner, name, false); + trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true); + + return namespaceDescriptor; } @Override diff --git a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java index 8f6da0fd7af..c9050ed0ad4 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java @@ -19,23 +19,9 @@ package org.jetbrains.jet.compiler; import com.google.common.io.Files; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.PropertyCodegen; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassKind; -import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.Modality; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.JavaNamespaceDescriptor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver; import org.jetbrains.jet.lang.types.JetType; @@ -43,16 +29,13 @@ import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lang.types.Variance; import org.junit.Assert; -import java.io.*; +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.StringReader; import java.lang.reflect.Method; import java.nio.charset.Charset; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashSet; -import java.util.List; -import java.util.Set; +import java.util.*; /** * @author Stepan Koltsov @@ -457,8 +440,7 @@ class NamespaceComparator { } private static boolean isRootNs(DeclarationDescriptor ns) { - // upyachka - return ns instanceof JavaNamespaceDescriptor && JavaDescriptorResolver.JAVA_ROOT.equals(ns.getName()); + return ns instanceof NamespaceDescriptor && ns.getContainingDeclaration() instanceof ModuleDescriptor; } private static class NamespacePrefixSerializer extends Serializer {